Initial commit
This commit is contained in:
Krzysztof Cieślik
833
OPTIMIZATION_PLAN.md
Normal file
833
OPTIMIZATION_PLAN.md
Normal file
@@ -0,0 +1,833 @@
|
||||
# Plan optymalizacji — MyApplication (HA Widget Panel)
|
||||
|
||||
Cel: maksymalna wydajność na AllWinner A13 (single-core 1.2GHz, 512MB RAM, Android 4.0, API 14).
|
||||
|
||||
---
|
||||
|
||||
## Spis treści
|
||||
|
||||
1. [Stack technologiczny](#1-stack-technologiczny)
|
||||
2. [System designu — Bauhaus / Swiss Grid](#2-system-designu--bauhaus--swiss-grid)
|
||||
3. [Konfiguracja buildu](#3-konfiguracja-buildu)
|
||||
4. [Rendering — Custom View](#4-rendering--custom-view)
|
||||
5. [GridView — lista widgetów](#5-gridview--lista-widgetów)
|
||||
6. [Ikony — Canvas drawing](#6-ikony--canvas-drawing)
|
||||
7. [StaticLayout — pre-obliczony tekst](#7-staticlayout--pre-obliczony-tekst)
|
||||
8. [Animacje — GPU only](#8-animacje--gpu-only)
|
||||
9. [Sieć — OkHttp + Retrofit](#9-sieć--okhttp--retrofit)
|
||||
10. [JSON — TypeAdaptery zamiast refleksji](#10-json--typeadaptery-zamiast-refleksji)
|
||||
11. [Wątki — HandlerThread](#11-wątki--handlerthread)
|
||||
12. [Pamięć — LruCache + SparseArray](#12-pamięć--lrucache--sparsearray)
|
||||
13. [Inicjalizacja przy starcie](#13-inicjalizacja-przy-starcie)
|
||||
14. [Języki](#14-języki)
|
||||
15. [Priorytety implementacji](#15-priorytety-implementacji)
|
||||
|
||||
---
|
||||
|
||||
## 1. Stack technologiczny
|
||||
|
||||
| Element | Wybór | Powód |
|
||||
|---|---|---|
|
||||
| Język | **Kotlin** | Identyczny bytecode co Java — zero różnicy runtime |
|
||||
| UI framework | **Natywne Android API 14** | Zero overhead bibliotek, pełna kontrola |
|
||||
| Tema | **Theme.Holo** | Natywna, zero zależności, dostępna od API 11 |
|
||||
| Lista widgetów | **android.widget.GridView** | Natywna, wbudowane recycling widoków, brak Jetpack |
|
||||
| Sieć | **OkHttp 3.12.x + Retrofit 2.6.4** | Ostatnie wersje wspierające API 14 |
|
||||
| JSON | **Gson + TypeAdaptery** | Streaming parsing bez refleksji |
|
||||
| **ZABRONIONE** | AppCompat, Material Design, RecyclerView, Jetpack, Compose, CardView | Zbędny overhead / wymaga API 21+ |
|
||||
|
||||
---
|
||||
|
||||
## 2. System designu — Bauhaus / Swiss Grid
|
||||
|
||||
### Paleta kolorów
|
||||
|
||||
```kotlin
|
||||
object Colors {
|
||||
const val WHITE = 0xFFFFFFFF.toInt() // tło, tekst na ciemnym
|
||||
const val BLACK = 0xFF000000.toInt() // tekst, obramowania, cień
|
||||
const val RED = 0xFFE23A24.toInt() // błędy, alarmy, akcent krytyczny
|
||||
const val YELLOW = 0xFFFAD02C.toInt() // aktywny stan, akcent główny
|
||||
const val BLUE = 0xFF0056B3.toInt() // info, przyciski, akcent drugorzędny
|
||||
const val GRAY = 0xFF888888.toInt() // wyłączone, disabled
|
||||
}
|
||||
```
|
||||
|
||||
Żadnych innych kolorów. Żadnych gradientów. Żadnego alpha blendingu poza animacjami opacity.
|
||||
|
||||
### Typografia — system monospace
|
||||
|
||||
```kotlin
|
||||
object Fonts {
|
||||
// Wbudowany w każde urządzenie z API 14 — zero overhead, zero KB w APK
|
||||
val REGULAR: Typeface = Typeface.create("monospace", Typeface.NORMAL)
|
||||
val BOLD: Typeface = Typeface.create("monospace", Typeface.BOLD)
|
||||
}
|
||||
```
|
||||
|
||||
Każdy `TextPaint` używa `Fonts.REGULAR` lub `Fonts.BOLD`. Żadnych innych krojów.
|
||||
|
||||
### Skala typograficzna
|
||||
|
||||
```
|
||||
Rola Rozmiar Waga Zastosowanie
|
||||
────────────────────────────────────────────────────
|
||||
value 20sp BOLD główna wartość encji (21.5°C, ON, 58%)
|
||||
label 12sp NORMAL nazwa encji
|
||||
secondary 10sp NORMAL jednostka, czas ostatniej aktualizacji
|
||||
```
|
||||
|
||||
### Siatka spacingu — tylko wielokrotności 4dp
|
||||
|
||||
```
|
||||
Padding wewnętrzny karty: 8dp
|
||||
Odstęp między kartami: 4dp
|
||||
Padding ekranu: 8dp
|
||||
Grubość borderu: 1dp lub 2dp
|
||||
Szerokość lewego paska: 4dp
|
||||
```
|
||||
|
||||
### Geometria — ZERO zaokrągleń
|
||||
|
||||
```kotlin
|
||||
// ŹLE — zaokrąglone rogi są ZABRONIONE
|
||||
canvas.drawRoundRect(rect, 8f, 8f, paint)
|
||||
|
||||
// DOBRZE — ostre rogi wszędzie
|
||||
canvas.drawRect(rect, paint)
|
||||
```
|
||||
|
||||
`android:radius` i `corners` w drawable — ZABRONIONE.
|
||||
|
||||
### Hard shadow — technika
|
||||
|
||||
Zamiast `elevation` — przesunięty czarny `View`:
|
||||
|
||||
```xml
|
||||
<FrameLayout android:padding="4dp">
|
||||
|
||||
<!-- Cień: ten sam rozmiar co karta, przesunięty o 4dp -->
|
||||
<View
|
||||
android:background="#000000"
|
||||
android:layout_width="match_parent"
|
||||
android:layout_height="match_parent"
|
||||
android:layout_marginLeft="4dp"
|
||||
android:layout_marginTop="4dp"/>
|
||||
|
||||
<!-- Karta na wierzchu -->
|
||||
<com.example.myapplication.ui.WidgetCardView
|
||||
android:layout_width="match_parent"
|
||||
android:layout_height="wrap_content"/>
|
||||
|
||||
</FrameLayout>
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 3. Konfiguracja buildu
|
||||
|
||||
### `app/build.gradle.kts`
|
||||
|
||||
```kotlin
|
||||
android {
|
||||
defaultConfig {
|
||||
minSdk = 14
|
||||
// Multidex WYŁĄCZONY — bez AppCompat/Material szacowane ~25K metod, poniżej limitu 65K
|
||||
resourceConfigurations += listOf("pl", "en")
|
||||
}
|
||||
|
||||
buildTypes {
|
||||
release {
|
||||
isMinifyEnabled = true
|
||||
isShrinkResources = true
|
||||
proguardFiles(
|
||||
getDefaultProguardFile("proguard-android-optimize.txt"),
|
||||
"proguard-rules.pro"
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
// AllWinner A13 = ARM Cortex-A8 = armeabi-v7a
|
||||
// Wyklucza x86/arm64 → mniejszy APK, szybsza instalacja
|
||||
splits {
|
||||
abi {
|
||||
isEnable = true
|
||||
reset()
|
||||
include("armeabi-v7a")
|
||||
isUniversalApk = false
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
dependencies {
|
||||
// Sieć — OK, nie są to UI wrappery
|
||||
implementation(libs.okhttp)
|
||||
implementation(libs.okhttp.logging)
|
||||
implementation(libs.retrofit)
|
||||
implementation(libs.retrofit.gson)
|
||||
implementation(libs.gson)
|
||||
implementation(libs.mpandroidchart)
|
||||
|
||||
// USUNIĘTE: AppCompat, Material, core-ktx, multidex, RecyclerView
|
||||
}
|
||||
```
|
||||
|
||||
### `res/values/themes.xml`
|
||||
|
||||
```xml
|
||||
<style name="AppTheme" parent="@android:style/Theme.Holo">
|
||||
<item name="android:windowBackground">@android:color/black</item>
|
||||
<item name="android:colorBackground">@android:color/black</item>
|
||||
</style>
|
||||
```
|
||||
|
||||
### Dlaczego odpada multidex
|
||||
|
||||
```
|
||||
AppCompat usunięty: -30 000 metod
|
||||
Material usunięty: -15 000 metod
|
||||
core-ktx usunięte: - 5 000 metod
|
||||
──────────────────────────────────────
|
||||
Szacowany total: ~25 000 metod ← poniżej limitu 65K
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 4. Rendering — Custom View
|
||||
|
||||
**Zasady:**
|
||||
- `Paint` / `TextPaint` / `Rect` / `RectF` — pola klasy, nigdy zmienne lokalne w `onDraw`
|
||||
- `Fonts.REGULAR` / `Fonts.BOLD` przypisane raz przy inicjalizacji obiektu Paint
|
||||
- `drawRect` zamiast `drawRoundRect` — ostre rogi, szybsze
|
||||
- Stała wysokość karty w `onMeasure` — eliminuje kosztowne obliczenia `wrap_content`
|
||||
- Settery z `if (field == value) return` — bez zbędnych `invalidate()`
|
||||
|
||||
```kotlin
|
||||
class WidgetCardView(context: Context) : View(context) {
|
||||
|
||||
private val dp = resources.displayMetrics.density
|
||||
|
||||
private val paintBg = Paint(Paint.ANTI_ALIAS_FLAG)
|
||||
private val paintBorder = Paint(Paint.ANTI_ALIAS_FLAG).apply {
|
||||
style = Paint.Style.STROKE
|
||||
strokeWidth = 2f * dp
|
||||
color = Colors.BLACK
|
||||
}
|
||||
private val paintLabel = TextPaint(Paint.ANTI_ALIAS_FLAG).apply {
|
||||
typeface = Fonts.REGULAR
|
||||
textSize = 12f * dp
|
||||
color = Colors.WHITE
|
||||
}
|
||||
private val paintValue = TextPaint(Paint.ANTI_ALIAS_FLAG).apply {
|
||||
typeface = Fonts.BOLD
|
||||
textSize = 20f * dp
|
||||
color = Colors.WHITE
|
||||
}
|
||||
private val paintSecondary = TextPaint(Paint.ANTI_ALIAS_FLAG).apply {
|
||||
typeface = Fonts.REGULAR
|
||||
textSize = 10f * dp
|
||||
color = Colors.GRAY
|
||||
}
|
||||
private val paintStripe = Paint(Paint.ANTI_ALIAS_FLAG)
|
||||
|
||||
private val rectBg = Rect()
|
||||
private val rectStripe = Rect()
|
||||
|
||||
private var labelLayout: StaticLayout? = null
|
||||
private var valueLayout: StaticLayout? = null
|
||||
private var secondaryLayout: StaticLayout? = null
|
||||
|
||||
var label: String = ""
|
||||
set(v) { if (field == v) return; field = v; rebuildLayouts(); invalidate() }
|
||||
var value: String = ""
|
||||
set(v) { if (field == v) return; field = v; rebuildLayouts(); invalidate() }
|
||||
var secondaryText: String = ""
|
||||
set(v) { if (field == v) return; field = v; rebuildLayouts(); invalidate() }
|
||||
var isActive: Boolean = false
|
||||
set(v) { if (field == v) return; field = v; invalidate() }
|
||||
var stripeColor: Int = Colors.BLUE
|
||||
set(v) { if (field == v) return; field = v; invalidate() }
|
||||
|
||||
override fun onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int) {
|
||||
val stripeW = (4f * dp).toInt()
|
||||
rectBg.set(0, 0, w, h)
|
||||
rectStripe.set(0, 0, stripeW, h)
|
||||
rebuildLayouts()
|
||||
}
|
||||
|
||||
private fun rebuildLayouts() {
|
||||
if (width == 0) return
|
||||
val contentW = width - rectStripe.width() - (8 * dp).toInt() - (4 * dp).toInt()
|
||||
labelLayout = buildLayout(label, paintLabel, contentW)
|
||||
valueLayout = buildLayout(value, paintValue, contentW)
|
||||
secondaryLayout = buildLayout(secondaryText, paintSecondary, contentW)
|
||||
}
|
||||
|
||||
private fun buildLayout(text: String, paint: TextPaint, w: Int): StaticLayout =
|
||||
StaticLayout(text, paint, w, Layout.Alignment.ALIGN_NORMAL, 1f, 0f, false)
|
||||
|
||||
override fun onDraw(canvas: Canvas) {
|
||||
val dp8 = 8f * dp
|
||||
val dp4 = 4f * dp
|
||||
|
||||
// Tło karty
|
||||
paintBg.color = if (isActive) Colors.YELLOW else Colors.BLACK
|
||||
canvas.drawRect(rectBg, paintBg)
|
||||
|
||||
// Pionowy pasek koloru (domena encji)
|
||||
paintStripe.color = stripeColor
|
||||
canvas.drawRect(rectStripe, paintStripe)
|
||||
|
||||
// Obramowanie
|
||||
canvas.drawRect(rectBg, paintBorder)
|
||||
|
||||
// Kolor tekstu zależy od tła
|
||||
val textColor = if (isActive) Colors.BLACK else Colors.WHITE
|
||||
paintLabel.color = textColor
|
||||
paintValue.color = textColor
|
||||
|
||||
val textX = rectStripe.width() + dp8
|
||||
|
||||
canvas.save()
|
||||
canvas.translate(textX, dp8)
|
||||
labelLayout?.draw(canvas)
|
||||
canvas.restore()
|
||||
|
||||
val labelH = labelLayout?.height?.toFloat() ?: 0f
|
||||
canvas.save()
|
||||
canvas.translate(textX, dp8 + labelH + dp4)
|
||||
valueLayout?.draw(canvas)
|
||||
canvas.restore()
|
||||
|
||||
val valueH = valueLayout?.height?.toFloat() ?: 0f
|
||||
canvas.save()
|
||||
canvas.translate(textX, dp8 + labelH + dp4 + valueH + dp4)
|
||||
secondaryLayout?.draw(canvas)
|
||||
canvas.restore()
|
||||
}
|
||||
|
||||
override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
|
||||
val w = MeasureSpec.getSize(widthMeasureSpec)
|
||||
val h = when {
|
||||
resources.configuration.screenHeightDp < 480 -> (72 * dp).toInt()
|
||||
else -> (88 * dp).toInt()
|
||||
}
|
||||
setMeasuredDimension(w, h)
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
**Czego unikać:**
|
||||
- `ConstraintLayout` w itemach gridu — skomplikowany algorytm pomiaru
|
||||
- `CardView` — wymaga AppCompat, ma elevation
|
||||
- Zagnieżdżenie ViewGroup > 2 poziomów
|
||||
- `wrap_content` na wysokości itemów gridu
|
||||
|
||||
---
|
||||
|
||||
## 5. GridView — lista widgetów
|
||||
|
||||
`android.widget.GridView` — natywny od API 1, zero zależności, wbudowane recycling widoków.
|
||||
Zastępuje `RecyclerView` (Jetpack — zabroniony).
|
||||
|
||||
```kotlin
|
||||
val gridView = GridView(this).apply {
|
||||
numColumns = when {
|
||||
resources.configuration.screenWidthDp >= 840 -> 4 // tablet landscape
|
||||
resources.configuration.screenWidthDp >= 600 -> 3 // tablet portrait
|
||||
else -> 2 // telefon
|
||||
}
|
||||
val dp4 = (4 * resources.displayMetrics.density).toInt()
|
||||
val dp8 = (8 * resources.displayMetrics.density).toInt()
|
||||
horizontalSpacing = dp4
|
||||
verticalSpacing = dp4
|
||||
setPadding(dp8, dp8, dp8, dp8)
|
||||
stretchMode = GridView.STRETCH_COLUMN_WIDTH
|
||||
adapter = widgetAdapter
|
||||
}
|
||||
```
|
||||
|
||||
### BaseAdapter
|
||||
|
||||
```kotlin
|
||||
class WidgetAdapter(
|
||||
private val context: Context,
|
||||
private var items: List<WidgetConfig>
|
||||
) : BaseAdapter() {
|
||||
|
||||
override fun getCount() = items.size
|
||||
override fun getItem(pos: Int) = items[pos]
|
||||
override fun getItemId(pos: Int) = items[pos].entityId.hashCode().toLong()
|
||||
override fun hasStableIds() = true // GridView może reużywać widoki
|
||||
|
||||
override fun getView(pos: Int, convertView: View?, parent: ViewGroup): View {
|
||||
// convertView = recycled view — ZAWSZE reużywaj jeśli istnieje
|
||||
val card = (convertView as? WidgetCardView) ?: WidgetCardView(context)
|
||||
val item = items[pos]
|
||||
card.label = item.friendlyName
|
||||
card.value = item.state
|
||||
card.secondaryText = item.lastUpdated
|
||||
card.isActive = item.isOn
|
||||
card.stripeColor = domainColor(item.domain)
|
||||
return card
|
||||
}
|
||||
|
||||
fun update(newItems: List<WidgetConfig>) {
|
||||
items = newItems
|
||||
notifyDataSetChanged()
|
||||
}
|
||||
|
||||
// Bezpośrednia aktualizacja stanu encji bez przebudowy adaptera
|
||||
fun updateState(entityId: String, newState: String, isOn: Boolean) {
|
||||
val idx = items.indexOfFirst { it.entityId == entityId }
|
||||
if (idx == -1) return
|
||||
items = items.toMutableList().also {
|
||||
it[idx] = it[idx].copy(state = newState, isOn = isOn)
|
||||
}
|
||||
// Aktualizuj tylko widoczną kartę jeśli jest na ekranie
|
||||
val card = gridView?.getChildAt(idx) as? WidgetCardView
|
||||
if (card != null) {
|
||||
card.value = newState
|
||||
card.isActive = isOn
|
||||
} else {
|
||||
notifyDataSetChanged()
|
||||
}
|
||||
}
|
||||
|
||||
private fun domainColor(domain: String) = when (domain) {
|
||||
"light" -> Colors.YELLOW
|
||||
"switch" -> Colors.BLUE
|
||||
"sensor" -> Colors.BLUE
|
||||
"binary_sensor" -> Colors.BLUE
|
||||
"script", "scene" -> Colors.RED
|
||||
else -> Colors.GRAY
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
**Uwaga:** `GridView` nie ma `DiffUtil` (Jetpack). Dla małej listy widgetów (< 30 pozycji)
|
||||
`notifyDataSetChanged()` przy zmianie konfiguracji jest akceptowalne. Przy aktualizacji
|
||||
samego stanu encji — bezpośrednia modyfikacja `WidgetCardView` bez przebudowy adaptera.
|
||||
|
||||
---
|
||||
|
||||
## 6. Ikony — Canvas drawing
|
||||
|
||||
Zakaz bitmap (PNG/JPG). Ikony rysowane bezpośrednio na `Canvas` jako kształty geometryczne.
|
||||
Styl Bauhaus: proste figury, jeden kolor, zero dekoracji.
|
||||
|
||||
```kotlin
|
||||
object HaIcons {
|
||||
|
||||
// Paint jako pole — zero alokacji przy każdym draw()
|
||||
private val fillPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
|
||||
style = Paint.Style.FILL
|
||||
}
|
||||
private val strokePaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
|
||||
style = Paint.Style.STROKE
|
||||
strokeWidth = 2f
|
||||
}
|
||||
private val tmpRect = RectF()
|
||||
|
||||
fun draw(canvas: Canvas, domain: String, x: Float, y: Float, size: Float, color: Int) {
|
||||
fillPaint.color = color
|
||||
strokePaint.color = color
|
||||
when (domain) {
|
||||
"light" -> drawLight(canvas, x, y, size)
|
||||
"switch" -> drawSwitch(canvas, x, y, size)
|
||||
"sensor" -> drawSensor(canvas, x, y, size)
|
||||
"binary_sensor" -> drawBinarySensor(canvas, x, y, size)
|
||||
"script", "automation" -> drawScript(canvas, x, y, size)
|
||||
else -> drawGeneric(canvas, x, y, size)
|
||||
}
|
||||
}
|
||||
|
||||
private fun drawLight(canvas: Canvas, x: Float, y: Float, s: Float) {
|
||||
// Kwadrat + promienie — geometryczna "lampa"
|
||||
tmpRect.set(x + s*0.25f, y + s*0.25f, x + s*0.75f, y + s*0.75f)
|
||||
canvas.drawRect(tmpRect, fillPaint)
|
||||
canvas.drawLine(x + s*0.5f, y, x + s*0.5f, y + s*0.2f, strokePaint)
|
||||
canvas.drawLine(x + s*0.5f, y + s*0.8f, x + s*0.5f, y + s, strokePaint)
|
||||
canvas.drawLine(x, y + s*0.5f, x + s*0.2f, y + s*0.5f, strokePaint)
|
||||
canvas.drawLine(x + s*0.8f, y + s*0.5f, x + s, y + s*0.5f, strokePaint)
|
||||
}
|
||||
|
||||
private fun drawSwitch(canvas: Canvas, x: Float, y: Float, s: Float) {
|
||||
// Prostokąt poziomy + blok po prawej
|
||||
tmpRect.set(x, y + s*0.35f, x + s, y + s*0.65f)
|
||||
canvas.drawRect(tmpRect, fillPaint)
|
||||
tmpRect.set(x + s*0.55f, y + s*0.15f, x + s*0.95f, y + s*0.85f)
|
||||
canvas.drawRect(tmpRect, fillPaint)
|
||||
}
|
||||
|
||||
private fun drawSensor(canvas: Canvas, x: Float, y: Float, s: Float) {
|
||||
// Krzyż — pomiar
|
||||
tmpRect.set(x + s*0.4f, y, x + s*0.6f, y + s)
|
||||
canvas.drawRect(tmpRect, fillPaint)
|
||||
tmpRect.set(x, y + s*0.4f, x + s, y + s*0.6f)
|
||||
canvas.drawRect(tmpRect, fillPaint)
|
||||
}
|
||||
|
||||
private fun drawBinarySensor(canvas: Canvas, x: Float, y: Float, s: Float) {
|
||||
// Kwadrat w kwadracie
|
||||
tmpRect.set(x + s*0.1f, y + s*0.1f, x + s*0.9f, y + s*0.9f)
|
||||
canvas.drawRect(tmpRect, strokePaint)
|
||||
tmpRect.set(x + s*0.3f, y + s*0.3f, x + s*0.7f, y + s*0.7f)
|
||||
canvas.drawRect(tmpRect, fillPaint)
|
||||
}
|
||||
|
||||
private fun drawScript(canvas: Canvas, x: Float, y: Float, s: Float) {
|
||||
// Trzy poziome paski — lista komend
|
||||
val h = s * 0.12f
|
||||
val gap = s * 0.25f
|
||||
for (i in 0..2) {
|
||||
tmpRect.set(x, y + gap * i + gap * 0.5f, x + s, y + gap * i + gap * 0.5f + h)
|
||||
canvas.drawRect(tmpRect, fillPaint)
|
||||
}
|
||||
}
|
||||
|
||||
private fun drawGeneric(canvas: Canvas, x: Float, y: Float, s: Float) {
|
||||
tmpRect.set(x + s*0.15f, y + s*0.15f, x + s*0.85f, y + s*0.85f)
|
||||
canvas.drawRect(tmpRect, fillPaint)
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
Ponieważ ikony są prostymi operacjami Canvas (kilka `drawRect` / `drawLine`), rasteryzacja
|
||||
jest natychmiastowa — nie potrzeba cache'owania bitmap.
|
||||
|
||||
---
|
||||
|
||||
## 7. StaticLayout — pre-obliczony tekst
|
||||
|
||||
`canvas.drawText()` mierzy tekst przy każdym `onDraw`. `StaticLayout` robi to raz.
|
||||
|
||||
```kotlin
|
||||
private fun buildLayout(text: String, paint: TextPaint, widthPx: Int): StaticLayout =
|
||||
StaticLayout(text, paint, widthPx, Layout.Alignment.ALIGN_NORMAL, 1f, 0f, false)
|
||||
|
||||
// W onDraw — zero mierzenia:
|
||||
canvas.save()
|
||||
canvas.translate(x, y)
|
||||
layout.draw(canvas)
|
||||
canvas.restore()
|
||||
```
|
||||
|
||||
**Reguły:**
|
||||
- Przebuduj tylko gdy zmienia się tekst **lub** `onSizeChanged`
|
||||
- `if (field == value) return` w każdym setterze przed `invalidate()`
|
||||
- Guard `if (width == 0) return` w `rebuildLayouts()`
|
||||
|
||||
---
|
||||
|
||||
## 8. Animacje — GPU only
|
||||
|
||||
Tylko właściwości animowane przez GPU via `ViewPropertyAnimator`.
|
||||
Zero animacji zmieniających layout — `width`/`height`/`margin`/`padding` wywołują
|
||||
`requestLayout()` co zabija wydajność.
|
||||
|
||||
```kotlin
|
||||
// Wysunięcie panelu konfiguracji z dołu
|
||||
fun revealPanel(panel: View) {
|
||||
panel.visibility = View.VISIBLE
|
||||
panel.translationY = panel.height.toFloat()
|
||||
panel.animate()
|
||||
.translationY(0f)
|
||||
.alpha(1f)
|
||||
.setDuration(200)
|
||||
.setInterpolator(DecelerateInterpolator())
|
||||
.start()
|
||||
}
|
||||
|
||||
// Chowanie panelu
|
||||
fun hidePanel(panel: View) {
|
||||
panel.animate()
|
||||
.translationY(panel.height.toFloat())
|
||||
.alpha(0f)
|
||||
.setDuration(150)
|
||||
.setInterpolator(LinearInterpolator())
|
||||
.withEndAction { panel.visibility = View.GONE }
|
||||
.start()
|
||||
}
|
||||
|
||||
// Feedback dotknięcia karty
|
||||
fun tapFeedback(card: View) {
|
||||
card.animate()
|
||||
.alpha(0.4f)
|
||||
.setDuration(80)
|
||||
.setInterpolator(LinearInterpolator())
|
||||
.withEndAction {
|
||||
card.animate().alpha(1f).setDuration(120).start()
|
||||
}
|
||||
.start()
|
||||
}
|
||||
```
|
||||
|
||||
### Tabela dozwolonych właściwości
|
||||
|
||||
```
|
||||
Właściwość GPU Zastosowanie
|
||||
──────────────────────────────────────────────────
|
||||
translationX/Y ✓ przesuwanie paneli, drawer
|
||||
scaleX/Y ✓ powiększenie aktywnego widgetu
|
||||
alpha ✓ fade, feedback dotknięcia
|
||||
rotation ✓ obrót ikony ładowania
|
||||
|
||||
width/height ✗ requestLayout() — ZABRONIONE
|
||||
margin/padding ✗ requestLayout() — ZABRONIONE
|
||||
layout_weight ✗ requestLayout() — ZABRONIONE
|
||||
backgroundColor ✗ software render — zmień kolor przez Paint w onDraw
|
||||
```
|
||||
|
||||
**Interpolatory:** tylko `LinearInterpolator` lub `DecelerateInterpolator`.
|
||||
**Czas trwania:** 80ms–250ms. Żadnych sprężyn, odbić, elastyczności.
|
||||
|
||||
---
|
||||
|
||||
## 9. Sieć — OkHttp + Retrofit
|
||||
|
||||
Jeden singleton na całą aplikację — `ConnectionPool` jest drogi w tworzeniu.
|
||||
|
||||
```kotlin
|
||||
object NetworkModule {
|
||||
|
||||
val okHttpClient: OkHttpClient by lazy {
|
||||
OkHttpClient.Builder()
|
||||
.connectionPool(ConnectionPool(3, 30, TimeUnit.SECONDS))
|
||||
.connectTimeout(10, TimeUnit.SECONDS)
|
||||
.readTimeout(15, TimeUnit.SECONDS)
|
||||
.cache(Cache(File(context.cacheDir, "ha_http"), 2L * 1024 * 1024))
|
||||
.addInterceptor(AuthInterceptor(token))
|
||||
.build()
|
||||
}
|
||||
|
||||
val retrofit: Retrofit by lazy {
|
||||
Retrofit.Builder()
|
||||
.baseUrl(baseUrl)
|
||||
.client(okHttpClient)
|
||||
.addConverterFactory(GsonConverterFactory.create(buildGson()))
|
||||
.build()
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 10. JSON — TypeAdaptery zamiast refleksji
|
||||
|
||||
Gson domyślnie używa refleksji — na A13 odczuwalne przy każdym parsowaniu.
|
||||
TypeAdapter = ręczne parsowanie strumieniowe, 3-5x szybsze.
|
||||
|
||||
```kotlin
|
||||
class HaEntityTypeAdapter : TypeAdapter<HaEntity>() {
|
||||
override fun read(reader: JsonReader): HaEntity {
|
||||
var entityId = ""; var state = ""; var friendlyName = ""
|
||||
reader.beginObject()
|
||||
while (reader.hasNext()) {
|
||||
when (reader.nextName()) {
|
||||
"entity_id" -> entityId = reader.nextString()
|
||||
"state" -> state = reader.nextString()
|
||||
"attributes" -> {
|
||||
reader.beginObject()
|
||||
while (reader.hasNext()) {
|
||||
when (reader.nextName()) {
|
||||
"friendly_name" -> friendlyName = reader.nextString()
|
||||
else -> reader.skipValue()
|
||||
}
|
||||
}
|
||||
reader.endObject()
|
||||
}
|
||||
else -> reader.skipValue() // nie parsuj niepotrzebnych pól
|
||||
}
|
||||
}
|
||||
reader.endObject()
|
||||
return HaEntity(entityId, state, friendlyName)
|
||||
}
|
||||
override fun write(out: JsonWriter, value: HaEntity?) {}
|
||||
}
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 11. Wątki — HandlerThread
|
||||
|
||||
Na single-core nie twórz wielu wątków — context switching jest kosztowny.
|
||||
Jeden `HandlerThread` na całą komunikację z HA.
|
||||
|
||||
```kotlin
|
||||
object HaWorker {
|
||||
private val thread = HandlerThread("ha-worker").also { it.start() }
|
||||
val handler = Handler(thread.looper)
|
||||
val mainThread = Handler(Looper.getMainLooper())
|
||||
|
||||
fun post(block: () -> Unit) = handler.post(block)
|
||||
fun postDelayed(ms: Long, block: () -> Unit) = handler.postDelayed(block, ms)
|
||||
fun cancelAll() = handler.removeCallbacksAndMessages(null)
|
||||
}
|
||||
```
|
||||
|
||||
**Dlaczego `HandlerThread` zamiast `Executors.newSingleThreadExecutor()`:**
|
||||
- `postDelayed` dla retry z exponential backoff
|
||||
- `removeCallbacks` do anulowania zakolejkowanych zadań bez dodatkowej synchronizacji
|
||||
- Wbudowana kolejka z priorytetem
|
||||
|
||||
---
|
||||
|
||||
## 12. Pamięć — LruCache + SparseArray
|
||||
|
||||
### Cache stanów encji
|
||||
|
||||
```kotlin
|
||||
object EntityStateCache {
|
||||
private val cache = LruCache<String, EntityState>(50)
|
||||
fun get(id: String) = cache.get(id)
|
||||
fun put(id: String, s: EntityState) = cache.put(id, s)
|
||||
fun evictAll() = cache.evictAll()
|
||||
}
|
||||
```
|
||||
|
||||
### SparseArray zamiast HashMap dla kluczy Int
|
||||
|
||||
```kotlin
|
||||
// ŹLE — autoboxing Int→Integer przy każdym get/put
|
||||
val viewTypes = HashMap<Int, Int>()
|
||||
|
||||
// DOBRZE — zero alokacji, zoptymalizowane dla kluczy int
|
||||
val viewTypes = SparseArray<Int>()
|
||||
```
|
||||
|
||||
### onTrimMemory — oddaj pamięć gdy system prosi
|
||||
|
||||
```kotlin
|
||||
class MainActivity : Activity() {
|
||||
override fun onTrimMemory(level: Int) {
|
||||
super.onTrimMemory(level)
|
||||
if (level >= ComponentCallbacks2.TRIM_MEMORY_MODERATE) {
|
||||
EntityStateCache.evictAll()
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### WeakReference w callbackach sieciowych
|
||||
|
||||
```kotlin
|
||||
// ŹLE — anonimowa klasa trzyma referencję do Activity
|
||||
client.newCall(req).enqueue(object : Callback {
|
||||
override fun onResponse(call: Call, response: Response) {
|
||||
textView.text = "..." // wyciek Activity po rotacji!
|
||||
}
|
||||
})
|
||||
|
||||
// DOBRZE
|
||||
class StateCallback(activity: MainActivity) : Callback {
|
||||
private val ref = WeakReference(activity)
|
||||
override fun onResponse(call: Call, response: Response) {
|
||||
ref.get()?.runOnUiThread { /* aktualizuj UI */ }
|
||||
}
|
||||
override fun onFailure(call: Call, e: IOException) {}
|
||||
}
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 13. Inicjalizacja przy starcie
|
||||
|
||||
```kotlin
|
||||
class App : Application() {
|
||||
|
||||
override fun onCreate() {
|
||||
super.onCreate()
|
||||
// Pierwsze połączenie w tle — tworzy connection pool przed pierwszym UI request
|
||||
HaWorker.post { warmupNetwork() }
|
||||
}
|
||||
|
||||
private fun warmupNetwork() {
|
||||
try {
|
||||
NetworkModule.okHttpClient
|
||||
.newCall(pingRequest())
|
||||
.execute()
|
||||
.close()
|
||||
} catch (_: IOException) {}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### Co kiedy jest przeliczane
|
||||
|
||||
```
|
||||
Zdarzenie Co się dzieje
|
||||
──────────────────────────────────────────────────────────────────
|
||||
Start aplikacji warmup connection pool w tle
|
||||
onSizeChanged karty rebuild StaticLayout (1x na widget)
|
||||
onDraw drawRect + HaIcons.draw + layout.draw
|
||||
→ ZERO alokacji, ZERO parsowania
|
||||
Zmiana stanu encji bezpośredni setter na WidgetCardView
|
||||
→ tylko ta karta wywołuje invalidate()
|
||||
onTrimMemory (MODERATE+) EntityStateCache.evictAll() → RAM zwolniony
|
||||
Obrócenie ekranu stany encji z EntityStateCache (bez sieci)
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 14. Języki
|
||||
|
||||
```
|
||||
res/values/strings.xml angielski (default)
|
||||
res/values-pl/strings.xml polski
|
||||
```
|
||||
|
||||
`resourceConfigurations += listOf("pl", "en")` wycina pozostałe tłumaczenia z bibliotek
|
||||
narzędziowych (~200KB oszczędności w APK).
|
||||
|
||||
---
|
||||
|
||||
## 15. Priorytety implementacji
|
||||
|
||||
```
|
||||
Priorytet Optymalizacja Wpływ
|
||||
──────────────────────────────────────────────────────────────
|
||||
KRYTYCZNY Brak AppCompat/Material → Theme.Holo RAM / metody
|
||||
Custom View — drawRect, brak zaokrągleń rendering
|
||||
Ikony jako Canvas draw (brak bitmap) rendering / RAM
|
||||
Jeden OkHttpClient singleton RAM
|
||||
|
||||
DUŻY StaticLayout (pre-obliczony tekst) rendering
|
||||
TypeAdaptery Gson CPU / parsing
|
||||
HandlerThread (1 wątek tła) CPU
|
||||
GridView z BaseAdapter + hasStableIds rendering
|
||||
|
||||
ŚREDNI EntityStateCache (LruCache) sieć / RAM
|
||||
SparseArray zamiast HashMap RAM
|
||||
onTrimMemory → czyszczenie cache RAM
|
||||
Animacje tylko GPU (ViewPropertyAnimator) jank
|
||||
Bezpośredni setter na kartę (bez adapter) rendering
|
||||
|
||||
MAŁY ABI splits (armeabi-v7a only) APK size
|
||||
isShrinkResources = true APK size
|
||||
resourceConfigurations (pl + en) APK size
|
||||
WeakReference w callbackach memory leaks
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Zależności po zmianach
|
||||
|
||||
```toml
|
||||
# gradle/libs.versions.toml
|
||||
# USUNIĘTO: AppCompat, Material, core-ktx, multidex
|
||||
|
||||
[versions]
|
||||
okhttp = "3.12.13"
|
||||
retrofit = "2.6.4"
|
||||
gson = "2.10.1"
|
||||
mpandroidchart = "v3.1.0"
|
||||
|
||||
[libraries]
|
||||
okhttp = { group = "com.squareup.okhttp3", name = "okhttp", version.ref = "okhttp" }
|
||||
okhttp-logging = { group = "com.squareup.okhttp3", name = "logging-interceptor", version.ref = "okhttp" }
|
||||
retrofit = { group = "com.squareup.retrofit2", name = "retrofit", version.ref = "retrofit" }
|
||||
retrofit-gson = { group = "com.squareup.retrofit2", name = "converter-gson", version.ref = "retrofit" }
|
||||
gson = { group = "com.google.code.gson", name = "gson", version.ref = "gson" }
|
||||
mpandroidchart = { group = "com.github.PhilJay", name = "MPAndroidChart", version.ref = "mpandroidchart" }
|
||||
```
|
||||
Reference in New Issue
Block a user