Search for:

Android-Arsenal – Kotlin

Eine einfache Android-Vorlage, mit der Sie erstellen k├Ânnen Android Projekt schnell.

Wie benutzt man ­čĹú

Einfach anklicken Schaltfl├Ąche, um ausgehend von dieser Vorlage ein neues Repo zu erstellen.

Fassung komponieren ÔşÉ

F├╝r die Compilation-Version, die sich in Entwicklung befindet, wechseln Sie zu Funktion / Montage Ast.

Eigenschaften ­čĽ╣

In Entwicklung ­čÜž

  • CI hinzuf├╝gen
  • Verwenden Sie Kotlin-DSL
  • F├╝gen Sie Espresso, Instrumentierung und Komponententests hinzu. Um einige der ├änderungen anzuzeigen, klicken Sie auf Hier.
  • Verwenden Sie Animationen. Um die ├änderungen anzuzeigen, klicken Sie auf Hier.
  • Verwenden Sie Griff. Um die ├änderungen anzuzeigen, klicken Sie auf Hier.
  • Migrieren nach Griff 2.31. Um die ├änderungen anzuzeigen, klicken Sie auf Hier.
  • Verwenden Sie Paging V3. Um die ├änderungen anzuzeigen, klicken Sie auf Hier.
  • Verwenden Sie ViewBinding. Um die ├änderungen anzuzeigen, klicken Sie auf Hier.
  • Migrieren nach JetPack Compose
  • Verwenden Sie den Detektor. Um die ├änderungen anzuzeigen, klicken Sie auf Hier.
  • Quark hinzuf├╝gen und flie├čen lassen. Um die ├änderungen anzuzeigen, klicken Sie auf Hier.
  • Ersetzen Sie die DataStore-Einstellungen. Um die ├änderungen anzuzeigen, klicken Sie auf Hier.
  • Migrieren Sie von RxJava 2 zu RxJava 3. Um die ├änderungen anzuzeigen, klicken Sie auf Hier.
  • F├╝gen Sie einen benutzerdefinierten Rx-Adapter hinzu, um die Netzwerkantwort zu verarbeiten. Um die ├änderungen anzuzeigen, klicken Sie auf Hier.

KI ­čĆş

Diese Vorlage wird verwendet GitHub-Aktionen als CI.

Verf├╝gbare Workflows sind wie folgt aufgelistet:

Aufgaben ­čöž

  • Gradle-Arzt: dependencyUpdates – Zeigt Abh├Ąngigkeitsaktualisierungen f├╝r das Projekt an.
  • Erkennen: detektAll – Statische Analyse des Kotlin-Codes f├╝r das gesamte Projekt auf einmal ausf├╝hren.

Verweise ­čžĚ

Beitrag ­čĄŁ

F├╝hlen Sie sich frei, ein Problem zu ├Âffnen oder eine Auszahlung f├╝r Fehler / Verbesserungen zu beantragen.

Das Ergebnis ­čô║

Komponieren

Lizenz ÔÜľ´ŞĆ

Android-Arsenal ÔÇô SDK

~ Beta Release
$version_release = 1.0.0
* Multi Platform Library *
* Compose UI Multi Platform *
* Update Compose Component *
* List Item Compose Desktop and Android *
* Grid Item Compose Desktop and Android *
* Vitamin Function *
* NutriRecyclerView Update *
// Add it in your root build.gradle at the end of repositories:

allprojects {
    repositories {
        ...
        maven { url 'https://jitpack.io' }
    }
}
dependencies {
    // library nutrition-framework
    implementation 'com.github.amirisback:nutrition-framework:1.0.0'
}
dependencies {
    // library nutrition-framework
    implementation("com.github.amirisback:nutrition-framework:1.0.0")
}

Das Min-API-Level ist auf 21 festgelegt, sodass der vorgestellte Ansatz f├╝r ├╝ber 94┬á% der Ger├Ąte geeignet ist, die Android verwenden. Dieses Projekt nutzt viele beliebte Bibliotheken und Tools des Android-├ľkosystems. Die meisten Bibliotheken liegen in einer stabilen Version vor, es sei denn, es gibt einen guten Grund, eine instabile Abh├Ąngigkeit zu verwenden.

Android-Arsenal – Outlook

­čŽő Butterfly hilft Ihnen beim Erstellen einer anpassbaren und anpassbaren Benutzeroberfl├Ąche f├╝r Android mit Jetpack WindowManager.
Es unterst├╝tzt auch n├╝tzliche Funktionen f├╝r Jetpack Compose und LiveData-Integration.

├ťberblick

­čîŚ Siehe dunkles Thema

Dunkles Thema

Demo-Projekt

Das Demoprojekt wurde mit erstellt Stream-Chat-SDK f├╝r Jetpack Compose. Um das Demoprojekt zu verstehen, w├Ąre es hilfreich, wenn Sie sich die folgenden Links ansehen:

Herunterladen

Gradl

F├╝gen Sie die folgenden Codes zu Ihren eigenen hinzu Wurzel build.gradle Datei (nicht Ihr build.gradle-Dateimodul).

allprojects {
    repositories {
        mavenCentral()
    }
}

F├╝gen Sie dann die unten stehende Abh├Ąngigkeit zu Ihrer eigenen hinzu Modul‘S build.gradle Datei.

dependencies {
    implementation "io.getstream:butterfly:1.0.1"
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.5.2"
}

Hinweis: Der Schmetterling beinhaltet Jetpack WindowManager f├╝r interne Fensterberechnung. Wenn Sie also WindowManager in Ihrem Projekt verwenden, stellen Sie sicher, dass Ihr Projekt dieselbe Version verwendet, oder deaktivieren Sie die Abh├Ąngigkeit, um Ihre eigene anzupassen.

SCHNAPPSCHUSS

Sehen Sie, wie Sie einen Snapshot importieren

Einschlie├člich SCHNAPPSCHUSS

Filmmaterial der aktuellen Entwicklungsversion von Butterfly, die folgen, ist verf├╝gbar die neuesten Versionen.

Um Snapshot-Versionen in Ihr Projekt zu importieren, f├╝gen Sie das folgende Code-Snippet zu Ihrer Gradle-Datei hinzu.

repositories {
   maven { url 'https://oss.sonatype.org/content/repositories/snapshots/' }
}

F├╝gen Sie dann die untere Abh├Ąngigkeit zu Ihrer eigenen hinzu Modul‘S build.gradle Datei.

dependencies {
    implementation "io.getstream:butterfly:1.0.2-SNAPSHOT"
}

Installieren Sie den Faltungsemulator

Wenn Sie keine zusammenklappbaren Ger├Ąte oder Emulatoren haben, k├Ânnen Sie eine zusammenklappbare Emulatorumgebung einrichten, indem Sie die folgenden Anweisungen befolgen:

­čĹë Suchen Installieren Sie den Faltungsemulator (Surface Duo 2)

Benutzen

Schmetterling verwendet Jetpack WindowManagerDaher w├Ąre es hilfreich zu verstehen, ob Sie Hintergrundwissen dar├╝ber haben Fenstermanager APIs.

Fenstergr├Â├če

WindowSize stellt Haltepunkte dar, die die Gr├Â├če des Bildschirms darstellen, auf dem das Layout angepasst wird, um am besten zum Inhalt zu passen und die Anforderungen des Layouts zu erf├╝llen. Butterfly folgt drei Breakpoints Material Design.

  • WindowSize.Compact: Die meisten Telefone im Hochformat. (0-599 dp-Bereich)
  • WindowSize.Medium: Die meisten Falt- und Tablets im Hochformat. (Bereich 600-839 dp)
  • WindowSize.Expanded: Die meisten Tablets im Querformat. (840+ dp-Bereich)

Sie k├Ânnen eine Kopie erhalten WindowSize Klasse sind getWindowSize() Methode auf Ihrem Aktivit├Ąt oder Fragment folgenderma├čen:

val windowSize: WindowSize = getWindowSize()
when (windowSize) {
    is WindowSize.Compact -> // the window size is compact.
    is WindowSize.Medium -> // the window size is medium.
    is WindowSize.Expanded -> // the window size is expanded.
}

GlobalWindowSize

Sie k├Ânnen vordefinierte Haltepunkte anpassen, die fr├╝her waren getWindowSize() mit GlobalWindowSize Objektklasse wie folgt:

GlobalWindowSize.compactWindowDpSize = 600
GlobalWindowSize.mediumWindowDpSize = 840

Sie k├Ânnen die Werksfunktion auch vollst├Ąndig anpassen WindowSize Klasse wie folgt:

GlobalWindowSize.windowSizeFactory = { windowPixelSize ->
    when {
        windowPixelSize.width < 0 -> throw IllegalArgumentException("Can't be negative")
        windowPixelSize.width < 600.dp2Px() -> WindowSize.Compact(windowPixelSize)
        windowPixelSize.width < 840.dp2Px() -> WindowSize.Medium(windowPixelSize)
        else -> WindowSize.Expanded(windowPixelSize)
    }
}

Haltung

Schaltzustand: FLAT ich HALF-OPENED von Google.

Die Positionsklasse stellt die Positionen des Ger├Ąts auf einem flexiblen Bildschirm oder Scharnier zwischen zwei physischen Anzeigefeldern dar.

  • K├Ârperhaltung.TableTop – Die Position des Ger├Ąts ist im Modus des Tisches (halb offen mit einem horizontalen Scharnier).
  • Haltung.Buch – Die Position des Ger├Ąts ist im Buchmodus (halb offen mit vertikalen Scharnieren).
  • Haltung.Normal – Die Position des Ger├Ąts befindet sich im Normalmodus.

Sie k├Ânnen die Haltung als Kotlin Flow an sich selbst beobachten Aktivit├Ąt oder Fragment folgenderma├čen:

lifecycleScope.launch(Dispatchers.Main) {
    lifecycle.repeatOnLifecycle(Lifecycle.State.STARTED) {
        postureFlow.collect { posture ->
            when (posture) {
                Posture.Normal -> // posture is Normal
                is Posture.TableTop -> // posture is TableTop
                is Posture.Book -> // posture is Book
            }
        }
        windowLayoutInfo.collect(::onWindowLayoutInfoUpdated)
    }
}

Hinweis: Stellen Sie sicher, dass Ihr Projekt enth├Ąlt Koroutinen ich androidx.lifecycle:lifecycle-runtime-ktx:2.4.0 Abh├Ąngigkeiten.

WindowLayoutInfo

WindowLayoutInfo enth├Ąlt eine Liste Anzeigefunktion-s befindet sich im Fenster. Sie k├Ânnen beobachten WindowLayoutInfo folgenderma├čen:

lifecycleScope.launch(Dispatchers.Main) {
    lifecycle.repeatOnLifecycle(Lifecycle.State.STARTED) {
        windowLayoutInfo.collect { windowLayoutInfo ->
            // something stuff            
        }
    }
}

Sie k├Ânnen auch die folgenden Informationen von erhalten WindowLayoutInfo wie in den folgenden Erweiterungen:

val isSeparating: Boolean = WindowLayoutInfo.isSeparating
val occlusionType: FoldingFeature.OcclusionType = WindowLayoutInfo.occlusionType 
val orientation: FoldingFeature.Orientation = WindowLayoutInfo.orientation
val state: FoldingFeature.State = WindowLayoutInfo.state

Faltfunktion

Faltfunktion was das Falten eines flexiblen Bildschirms oder Scharniers zwischen zwei physischen Bildschirmplatten beschreibt. Sie k├Ânnen die folgenden Erweiterungen verwenden, um den ├ťberlappungsstatus und die Ger├Ąteposition zu ├╝berpr├╝fen:

val foldingFeature = windowLayoutInfo.displayFeatures.findFoldingFeature()
val posture = foldingFeature?.toPosture()
val isTableTopPosture = foldingFeature?.isTableTopPosture
val isBookPosture = foldingFeature?.isBookPosture
val isHalfOpened = foldingFeature?.isHalfOpened
val isFlat = foldingFeature?.isFlat
val isVertical = foldingFeature?.isVertical
val isHorizontal = foldingFeature?.isHorizontal

Scharniergr├Â├če

Wenn Ihr Klappger├Ąt klappbar ist, k├Ânnen Sie die Scharniergr├Â├če mit den folgenden Erweiterungen erhalten:

val hingePxSize: Int = foldingFeature.hingePxSize
val hingeDpSize: Int = foldingFeature.hingeDpSize
val hingeWidthPxSize: Int = foldingFeature.hingeWidthPxSize
val hingeHeightPxSize: Int = foldingFeature.hingeHeightPxSize
val hingeWidthDpSize: Int = foldingFeature.hingeWidthDpSize
val hingeHeightDpSize: Int = foldingFeature.hingeHeightDpSize

WindowInfoActivity

Schmetterlingstr├Ąger WindowInfoActivitydie Fensterkonfigurationen und -aktualisierungen ├╝berwacht WindowLayoutInfo. Es gibt eine Vorgabe windowSize Eigentum und onWindowLayoutInfoUpdated abstrakte Methode wie im folgenden Beispiel:

class MainActivity : WindowInfoActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // windowSize property will be initialized lazily.
        when (windowSize) {
            is WindowSize.Compact -> 
            ...
        }
    }

    override fun onWindowLayoutInfoUpdated(windowLayoutInfo: WindowLayoutInfo) {
        val foldingFeature = windowLayoutInfo.displayFeatures.findFoldingFeature() ?: return
        when (val posture = foldingFeature.toPosture()) {
            Posture.Normal -> Log.d(tag, "[Posture.Normal] ${posture.size}")
            is Posture.TableTop -> Log.d(tag, "[Posture.TableTop] ${posture.size}")
            ...
        }
    }
}

Vordefiniert windowSize Die Eigenschaft wird faul und initialisiert onWindowLayoutInfoUpdated wird aktualisiert wann WindowLayoutInfo Konfiguration ge├Ąndert. Da das gleiche Konzept, k├Ânnen Sie erweitern WindowInfoFragment f├╝r dich Fragment.

Schmetterling f├╝r Jetpack Compose

Butterfly unterst├╝tzt Jetpack Compose, um anpassbare und anpassbare Benutzeroberfl├Ąchen zu erstellen. F├╝gen Sie zuerst die unten stehende Sucht zu Ihrer eigenen hinzu Modul build.gradle Datei.

dependencies {
    implementation "io.getstream:butterfly-compose:1.0.1"
}

WindowDpSize

WindowDpSize stellt Haltepunkte dar, die die Bildschirmgr├Â├če darstellen, bei der das Layout so angepasst wird, dass es am besten zum Inhalt passt und die Anforderungen des Layouts erf├╝llt. Butterfly folgt drei Breakpoints Material Design.

Sie k├Ânnen sich ein Beispiel vorstellen WindowDpSize Klasse sind rememberWindowDpSize() Methode auf Ihrem Aktivit├Ąt oder Fragment folgenderma├čen:

val windowDpSize: WindowDpSize = rememberWindowDpSize()
when (windowDpSize) {
    is WindowSize.Compact -> MainScreenRegular()
    is WindowSize.Medium -> MainScreenMedium()
    is WindowSize.Expanded -> MainScreenExpanded()
}

Hinweis: Auch WindowSizeSie k├Ânnen auch vordefinierte Haltepunkte anpassen, die fr├╝her waren rememberWindowDpSize mit GlobalWindowSize Objektklasse.

Haltung

Sie k├Ânnen eine bekommen Zustand von Haltung um anpassbare und anpassbare Benutzeroberfl├Ąchen zu erstellen postureState Verl├Ąngerung auf Ihrem Aktivit├Ąt ich Fragment folgenderma├čen:

val postureState: State<Posture> = postureState
when (postureState.value) {
    Posture.Normal -> // posture is Normal
    is Posture.TableTop -> // posture is TableTop
    is Posture.Book -> // posture is Book
}

WindowLayoutInfo

WindowLayoutInfo enth├Ąlt eine Liste Anzeigefunktion-s befindet sich im Fenster. Du kannst es bekommen Zustand des WindowLayoutInfo folgenderma├čen:

val windowLayoutInfoState: State<WindowLayoutInfo> = windowLayoutInfoState
val foldingFeature = windowLayoutInfoState.value.displayFeatures.findFoldingFeature()
...

ZusammensetzungLokal

Sie k├Ânnen Beispiele weiterleiten WindowDpSize ich Posture string Zusammensetzung implizit wie folgt:

CompositionLocalProvider(LocalWindowDpSize provides rememberWindowDpSize()) {
    val windowDpSize = LocalWindowDpSize.current
    ...
}

CompositionLocalProvider(LocalPosture provides postureState.value) {
    val posture = LocalPosture.current
    ...                
}

Scharniergr├Â├če

Wenn Ihr Klappger├Ąt klappbar ist, k├Ânnen Sie die Scharniergr├Â├če mit den folgenden Erweiterungen erhalten:

val hingeDp: Dp = FoldingFeature.hingeDp
val hingeDpSize: DpSize = FoldingFeature.hingeDpSize
val hingeWidthDp: Dp = FoldingFeature.hingeWidthDp
val hingeHeightDp: Dp = FoldingFeature.hingeHeightDp

Butterfly f├╝r LiveData-Integration

Schmetterlingstr├Ąger Lebensdaten Integration, mit der Sie ├änderungen beobachten k├Ânnen, die aussehen wie Lebensdaten. F├╝gen Sie zuerst die unten stehende Sucht zu Ihrer eigenen hinzu Modul build.gradle Datei.

dependencies {
    implementation "io.getstream:butterfly-livedata:1.0.1"
}

Sie k├Ânnen beobachten Lebensdaten von Posture ich WindowLayoutInfo auf deinem Aktivit├Ąt ich Fragment wie im folgenden Beispiel unten:

postureLiveData().observe(this) { posture ->
    // do something
}

windowLayoutInfoLiveData().observe(this) { windowLayoutInfo ->
    // do something
}

Ist diese Bibliothek n├╝tzlich f├╝r Sie? ÔŁĄ´ŞĆ

Unterst├╝tzen Sie dies durch Ihren Beitritt Sterngucker f├╝r dieses Depot. ԺɴŞĆ
Folgen Sie auch Strom auf Twitter f├╝r unsere n├Ąchsten Kreationen!

Copyright 2022 Stream.IO, Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

   http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

Android-Arsenal – HTML

Android-Bibliothek, die HTML-Unterst├╝tzung f├╝r Jetpack Compose-Texte bereitstellt.

Konfiguration

Zur h├Âchsten Ebene hinzuf├╝gen gradle.build Datei

allprojects {
    repositories {
        maven { url "https://jitpack.io" }
    }
}

F├╝gen Sie ein Anwendungsmodul hinzu gradle.build Datei.

dependencies {
    implementation 'com.github.ireward.compose-html:1.0.1'
}

Benutzen

F├╝rs Erste komponiert Text das Layout bietet keine HTML-Unterst├╝tzung. Diese Bibliothek f├╝llt diese L├╝cke, indem sie das Komponierte entdeckt HtmlText Zeitplan, der darauf aufbaut Text Zeitplan u Span/Spannable Android-Klasse. Seine API ist wie folgt:

HtmlText(
    text = htmlString,
    linkClicked = { link ->
        Log.d("linkClicked", link)
    }
)

Und dies sind alles verf├╝gbare Parameter, mit denen Sie das Standardverhalten ├Ąndern k├Ânnen:

fun HtmlText(
    text: String,
    modifier: Modifier = Modifier,
    style: TextStyle = TextStyle.Default,
    softWrap: Boolean = true,
    overflow: TextOverflow = TextOverflow.Clip,
    maxLines: Int = Int.MAX_VALUE,
    onTextLayout: (TextLayoutResult) -> Unit = {},
    linkClicked: (String) -> Unit = {},
    fontSize: TextUnit = 14.sp,
    flags: Int = HtmlCompat.FROM_HTML_MODE_COMPACT,
    URLSpanStyle: SpanStyle = SpanStyle(
        color = linkTextColor(),
        textDecoration = TextDecoration.Underline
    )
)

HtmlText unterst├╝tzt fast genauso viel HTML-Tags als android.widget.TextView funktioniertmit Ausnahme <img> Etikett und <ul>da letzteres teilweise unterst├╝tzt wird, wie HtmlText zeigt Listenelemente korrekt an, f├╝gt jedoch keine Markierung hinzu (ÔÇó)

Was folgt, sind Screenshots aus der begleitenden Pr├Ąsentations-App, die sich in demselben Repo befindet, wo alle HTML-Tags zum Vergleich nebeneinander angezeigt werden HtmlText mit android.widget.TextView: