Napier

Napier est une bibliothèque de journalisation pour Kotlin Multiplatform.
Il prend en charge Android, Darwin(iOS, macOS, watchOS, tvOS), JVM, JavaScript.
Les journaux écrits dans le module commun sont affichés sur le visualiseur d'enregistreurs de chaque plateforme.

Aperçu

Androïde

format : [Class name]$[Method name]: [Your log]

utilise le android.util.Log (Logcat)

Darwin (iOS, macOS, watchOS, tvOS) [Intel/Apple Silicon]

format : [Date time][Symbol][Log level][Class name].[Method name] - [Your log]

Ajout de l'étiquette [async] à la fin, si elle est appelée à partir de fonctions de suspension.

utilise l' print

Javascript

utilise le console.log

JVM

utilise le java.util.logging.Logger

• exemple de code commun

 class Sample {

    fun hello (): String {
        Napier .v( " Hello napier " )
        Napier .d( " optional tag " , tag = " your tag " )

        return " Hello Napier "
    }

    suspend fun suspendHello (): String {
        Napier .i( " Hello " )

        delay( 3000L )

        Napier .w( " Napier! " )

        return " Suspend Hello Napier "
    }

    fun handleError () {
        try {
            throw Exception ( " throw error " )
        } catch (e : Exception ) {
            Napier .e( " Napier Error " , e)
        }
    }
}

Télécharger

Dépôt

Vous pouvez télécharger cette bibliothèque depuis le référentiel MavenCentral ou jCenter.

• Centrale Maven

Vous pouvez le télécharger à partir de 1.4.1 .
Le nom du package est io.github.aakira

repositories {
    mavenCentral()
}

• jCentre

Vous pouvez le télécharger jusqu'à 1.4.1 .
Le nom du package est com.github.aakira

repositories {
    jCenter()
}

Version

Définissez le nom de la version dans votre build.gradle

def napierVersion = "[latest version]"

Commun

Ajoutez la dépendance à vos dépendances commonMain

• génial

sourceSets {
    commonMain {
        dependencies {
            // ...
            implementation " io.github.aakira:napier: $n apierVersion "
        }
    }
}

• nœuds

sourceSets {
    val commonMain by getting {
        dependencies {
            implementation( " io.github.aakira:napier: $napierVersion " )
        }
    }
}

Usage

Comment utiliser

Module commun

 // verbose log
Napier .v( " Hello napier " )
Napier .v { " Hello napier " }

// you can set a tag for each log
Napier .d( " optional tag " , tag = " your tag " )
Napier .d(tag = " your tag " ) { " optional tag " }

try {
    .. .
} catch (e : Exception ) {
    // you can set the throwable
    Napier .e( " Napier Error " , e)
    Napier .e(e) { " Napier Error " }
}

// you can also use top-level function
log { " top-level " }
log(tag = " your tag " ) { " top-level " }

Initialiser

Vous devez initialiser le Napier dans votre module.

Androïde

 Napier .base( DebugAntilog ())

IOS

• Écrivez le code d'initialisation dans votre projet kotlin mpp.

 fun debugBuild () {
    Napier .base( DebugAntilog ())
}

|argument|type|description| |-|-| |coroutinesSuffix|Boolean|Ajout d'une étiquette [async] à la fin, si elle est appelée à partir de fonctions de suspension|

• Appelez le code d'initialisation du projet iOS.

 NapierProxyKt . debugBuild ( )

Effacer l'antilog

 Napier .takeLogarithm()

Niveau de journalisation

Plate-forme	Échantillon
VERBEUX	Napier.v()
DÉBOGUER	Napier.d()
INFOS	Napier.i()
AVERTISSEMENT	Napier.w()
ERREUR	Napier.e()
AFFIRMER	Napier.wtf()

Exécuter le fil de discussion en arrière-plan

Vous pouvez utiliser cette bibliothèque sur le fil d'arrière-plan sur iOS en utilisant Kotlin.coroutines en tant que natif-mt.

• Définir la portée

 internal val mainScope = SharedScope ( Dispatchers . Main )

internal val backgroundScope = SharedScope ( Dispatchers . Default )

internal class SharedScope ( private val context : CoroutineContext ) : CoroutineScope {
    private val job = Job ()
    private val exceptionHandler = CoroutineExceptionHandler { _, throwable ->
        println ( " [Coroutine Exception] $throwable " )
    }

    override val coroutineContext : CoroutineContext
        get() = context + job + exceptionHandler
}

• Usage

backgroundScope.launch {
    suspendFunction()
}

Avancement

Vous pouvez injecter Antilog personnalisé.
Vous devez donc modifier les Antilogs dans la version de débogage ou la version release.

Crashlytiques

Exemples de Crashlytics AntiLog

Les exemples de projets utilisent Firebase Crashlytics.
Vous devez définir les fichiers d'authentification sur android/google-services.json et ios/Napier/GoogleService-Info.plist .

Vérifiez le document Firebase. [Android, iOS]

• Androïde

Écrivez ceci dans votre classe d'application.

 if ( BuildConfig . DEBUG ) {
    // Debug build

    // disable firebase crashlytics
    FirebaseCrashlytics .getInstance().setCrashlyticsCollectionEnabled( false )
    // init napier
    Napier .base( DebugAntilog ())
} else {
    // Others(Release build)

    // enable firebase crashlytics
    FirebaseCrashlytics .getInstance().setCrashlyticsCollectionEnabled( true )
    // init napier
    Napier .base( CrashlyticsAntilog ( this ))
}

• IOS

Écrivez ceci dans votre AppDelegate.

 #if DEBUG
// Debug build

// init napier
NapierProxyKt . debugBuild ( )

#else
// Others(Release build)

// init firebase crashlytics
FirebaseApp . configure ( )

// init napier
NapierProxyKt . releaseBuild ( antilog : CrashlyticsAntilog (
    crashlyticsAddLog : { priority , tag , message in
        Crashlytics . crashlytics ( ) . log ( " ( String ( describing : tag ) ) : ( String ( describing : message ) ) " )
} ,
    crashlyticsSendLog : { throwable in
        Crashlytics . crashlytics ( ) . record ( error : throwable )
} ) )
#endif 

Licence

 Copyright (C) 2019 A.Akira

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

https://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.

Crédit

Cette bibliothèque est inspirée de Timber.
Je recommande de l'utiliser s'il prend en charge le projet multiplateforme Kotlin.

Merci pour les conseils.
@horita-yuya, @terachanple