Przejdź do treści
Biblioteka skilli
Programowanie · Budowanie i kod

android-sdk

/android-sdk

Eksperckie wsparcie w SDK Android: komponenty architektury, cykl życia Activity i Fragment, uprawnienia, WorkManager i optymalizacja Gradle.

Repozytorium
Agent-Skills ↗
Licencja
MIT
Ostatnia zmiana repozytorium
01.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
2
Przestarzałość

Brak sygnałów. Repozytorium zmienione 01.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Eksperckie wsparcie w SDK Android: komponenty architektury, cykl życia Activity i Fragment, uprawnienia, WorkManager i optymalizacja Gradle.

Oryginalny opis (EN)

Expert Android SDK assistance covering Android architecture components, Activity/Fragment lifecycles, permissions, background work with WorkManager, and Gradle build optimizations. Use when building native Android applications, configuring ProGuard/R8, or interacting with platform SDK APIs.

Jak działa

  1. When to Use
  2. Quick Start
  3. Core Concepts
  4. Common Patterns
  5. Best Practices
  6. Troubleshooting
  7. References
Sekcje z nagłówków SKILL.md, w oryginale · 154 linii, 582 słów
Podgląd SKILL.md
---
name: android-sdk
description: Expert Android SDK assistance covering Android architecture components, Activity/Fragment lifecycles, permissions, background work with WorkManager, and Gradle build optimizations. Use when building native Android applications, configuring ProGuard/R8, or interacting with platform SDK APIs.
---

# Android SDK

The traditional Android development toolkit (Views, Activities, Fragments, XML) using Kotlin/Java. Essential for maintaining the vast ecosystem of pre-Compose applications.

## When to Use

- **Native Android Development**: Building high-performance, platform-specific Android applications using Java or Kotlin.
- **Hardware & Sensor Access**: Interfacing with Bluetooth Low Energy, camera hardware, biometric sensors, and NFC directly.
- **Background Task Scheduling**: Managing deferred, periodic, or guaranteed background jobs using WorkManager and foreground services.
- **Deep System Integration**: Implementing custom launcher widgets, notification channels, accessibility services, and device admin policies.

## Quick Start

```kotlin
// build.gradle.kts: viewBinding = true

class MainActivity : AppCompatActivity() {
    private lateinit var binding: ActivityMainBinding

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityMainBinding.inflate(layoutInflater)
        setContentView(binding.root)

        binding.myButton.setOnClickListener {
            Toast.makeText(this, "Clicked!", Toast.LENGTH_SHORT).show()
        }
    }
}
```

## Core Concepts

### Activity & Fragment Lifecycles

Activities represent single screens with user interfaces; lifecycle callbacks manage resource acquisition and release to prevent memory leaks during configuration changes:

```kotlin
class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()
        setContentView(R.layout.activity_main)
    }

    override fun onStart() {
        super.onStart()
        // Connect sensors, start location listener
    }

    override fun onStop() {
        super.onStop()
        // Release heavy sensor streams to preserve battery
    }
}
```

### Dependency Injection with Hilt

Hilt standardizes Dagger dependency injection across Android components with predefined scopes tied to Android lifecycles:

```kotlin
@HiltAndroidApp
class MainApplication : Application()

@AndroidEntryPoint
class UserProfileFragment : Fragment() {
    @Inject lateinit var analyticsTracker: AnalyticsTracker
    private val viewModel: UserViewModel by viewModels()
}
```

### Permissions Architecture & Runtime Requests

Modern Android requires fine-grained runtime permission requests before accessing sensitive hardware or user records:

```kotlin
val requestPermissionLauncher = registerForActivityResult(
    ActivityResultContracts.RequestPermission()
) { isGranted: Boolean ->
    if (isGranted) {
        openCamera()
    } else {
        showPermissionRationaleDialog()
    }
}

// Request permission when user triggers action
requestPermissionLauncher.launch(Manifest.permission.CAMERA)
```

## Common Patterns

### Background Processing with WorkManager

**Problem**: Long-running background sync operations get terminated by modern Android battery optimization (Doze mode).  
**Solution**: Schedule persistent background jobs with WorkManager and constraints.

```kotlin
class SyncWorker(ctx: Context, params: WorkerParameters) : CoroutineWorker(ctx, params) {
    override suspend fun doWork(): Result {
        return try {
            repository.syncData()
            Result.success()
        } catch (e: Exception) {
            Result.retry()
        }
    }
}

// Enqueue with network constraint
val constraints = Constraints.Builder()
    .setRequiredNetworkType(NetworkType.CONNECTED)
    .setRequiresBatteryNotLow(true)
    .build()

val syncRequest = PeriodicWorkRequestBuilder<SyncWorker>(1, TimeUnit.HOURS)
    .setConstraints(constraints)
    .build()

WorkManager.getInstance(context).enqueueUniquePeriodicWork(
    "DataSync", ExistingPeriodicWorkPolicy.KEEP, syncRequest
)
```

## Best Practices

**Do**:

- Adopt Edge-to-Edge Display: Target Android 15+ edge-to-edge system bars using WindowInsetsCompat.
- Use WorkManager for Background Tasks: Never spawn unmanaged background threads that get killed by battery optimizations (Doze).
- Enforce ViewBinding / Compose: Eliminate error-prone `findViewById` lookups by using ViewBinding or modern Jetpack Compose.
- Validate Scoped Storage: Store application files in private app storage (`context.filesDir`) or use the Storage Access Framework for public files.

**Don't**:

- Block the Main (UI) Thread: Keep networking, JSON parsing, and database transactions strictly on IO coroutine dispatchers.
- Hardcode dimensions or text: Always use `res/values/strings.xml` for localization and `res/values/dimens.xml` or density-independent pixels (`dp`).
- Hold static references to Context: Retaining an Activity context in static singletons causes permanent memory leaks.

## Troubleshooting

| Error                                          | Cause                                               | Solution                                    |
| :--------------------------------------------- | :-------------------------------------------------- | :------------------------------------------ |
| `ANR (App Not Responding)`                     | Blocking main thread for >5s.                       | Move work to `Dispatchers.IO` (Coroutines). |
| `IllegalStateException: Fragment not attached` | Accessing context after detachment.                 | Check `isAdded` or use `MainScope` safely.  |
| `Memory Leak`                                  | Holding Activity reference in Singleton/Background. | Use `WeakReference` or Application Context. |

## References

- [Android Developer Guides](https://developer.android.com/guide)
- [Guide to App Architecture](https://developer.android.com/topic/architecture)

Wersje

W bazie nie ma innych skilli o nazwie android-sdk.

Migawka bazy z 13.11.2026 · wersja paczki 2f7b7fb8ba3b (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 95android-native
    Opisuje natywne API platformy Android poza UI: cykl życia Activity i Fragment, Keystore, BiometricPrompt, EncryptedSharedPreferences, WorkManager, NFC, usługi pierwszoplanowe, ContentProvider, App Links, reguły ProGuard/R8 i model uprawnień.
  • 100android-studio
    Eksperckie wsparcie IDE Android Studio: synchronizacja Gradle, Logcat, Layout Inspector, SDK Manager i wirtualne urządzenia AVD.
  • 100android-background-workmanager-services
    Planuje odroczone, gwarantowane zadania w tle i okresowe workery na Androidzie, z użyciem WorkManager.
  • 90kotlin-android
    Buduje i aktualizuje natywne aplikacje Android w Kotlinie z Compose lub View, dbając o zgodność z Gradle, AGP i SDK.
  • 100android-expert
    Eksperckie wsparcie w rozwoju Android z Jetpack Compose, Material Design, ViewModel i nowoczesną architekturą.
  • 80role-mobile:android-native
    Wspiera tworzenie natywnych aplikacji Android w Kotlinie: Jetpack Compose, Room, Hilt, korutyny i Gradle KTS.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.