debug panel
1.0.0
O principal objetivo desta biblioteca é ter uma definição de classe em seu código comum que especifica como o painel de depuração deve ser construído. Usando esta definição, a biblioteca gera:
A lista de dados de exibição criada pelo caso de uso pode ser passada para um modelo de exibição incorporado que lida com as interações do usuário. Você tem a opção de usar a interface do usuário padrão que vem com a biblioteca ou para construir a sua.
A biblioteca é publicada para o repositório de Maven Maven da Mirego, portanto, verifique se ele incluía em seu bloco dependencyResolutionManagement seu cenário.gradle.kts.
dependencyResolutionManagement {
repositories {
// ...
maven( " https://s3.amazonaws.com/mirego-maven/public " )
}
}No seu arquivo de nível superior Build.gradle.kts, adicione a referência ao plugin KSP:
plugins {
// ...
id( " com.google.devtools.ksp " ) version " 1.9.21-1.0.15 " apply false
}No arquivo computal do seu módulo, o arquivo gradle.kts adicione a referência ao plugin KSP:
plugins {
// ...
id( " com.google.devtools.ksp " )
} Adicione também as dependências core e annotations , juntamente com o diretório de origem gerado pelo KSP:
val commonMain by getting {
dependencies {
// ...
api( " com.mirego.trikot:viewmodels-declarative-flow:x.y.z " )
api( " com.mirego.debugpanel:core:x.y.z " )
implementation( " com.mirego.debugpanel:annotations:x.y.z " )
}
kotlin.srcDir( " build/generated/ksp/metadata/commonMain/kotlin " )
}Não se esqueça de exportar a dependência central para a estrutura do iOS:
kotlin {
cocoapods {
framework {
// ...
export( " com.mirego.trikot:viewmodels-declarative-flow:x.y.z " )
export( " com.mirego.debugpanel:core:x.y.z " )
}
}
}Você também precisa adicionar a referência do compilador ao bloco de dependências:
dependencies {
add( " kspCommonMainMetadata " , " com.mirego.debugpanel:compiler:x.y.z " )
} A interface do usuário da amostra é resolvida automaticamente do módulo comum, pois incluímos a biblioteca com a função api() .
Se você tiver alguns problemas com um arquivo META-INF/versions/9/previous-compilation-data.bin , durante a compilação, poderá adicioná-lo aos recursos excluídos dentro do arquivo Build.kts do aplicativo Android:
android {
packaging {
resources {
excludes + = listOf (
" META-INF/versions/9/previous-compilation-data.bin "
)
}
}
}Se você deseja usar a interface do usuário da amostra no iOS, inclua o pod no poder do aplicativo:
pod 'Trikot/viewmodels.declarative.SwiftUI.flow', :git => '[email protected]:mirego/trikot.git', :tag => 'x.y.z', :inhibit_warnings => true
pod 'DebugPanel', :git => '[email protected]:mirego/debug-panel.git', :tag => 'x.y.z', :inhibit_warnings => true
No módulo do seu comum, crie uma classe com a anotação @debugpanel. Você pode encontrar os diferentes componentes disponíveis na tabela abaixo.
@DebugPanel(prefix = " MyProject " , packageName = " com.myproject.app.generated " )
data class DebugPanelConfig (
val toggle : DebugPanelToggle ,
val label : DebugPanelLabel ,
val textField : DebugPanelTextField ,
val button : DebugPanelButton ,
val picker : DebugPanelPicker ,
val datePicker : DebugPanelDatePicker ,
val enumPicker : SomeEnum
) Depois que a configuração for concluída, você pode executar a tarefa kspCommonMainMetadata Gradle para gerar os arquivos específicos para o seu projeto.
Agora você deve ter MyProjectDebugPanelUseCase.kt , MyProjectDebugPanelUseCaseImpl.kt , MyProjectDebugPanelRepository.kt e MyProjectDebugPanelRepositoryImpl.kt Disponível em sua classe.
Tudo o que você precisa fazer agora é instanciar as implementações:
private val repository : MyProjectDebugPanelRepository = MyProjectDebugPanelRepositoryImpl ()
private val useCase : MyProjectDebugPanelUseCase = MyProjectDebugPanelUseCaseImpl (repository)
/* ... */
class ParentViewModelImpl (
coroutineScope : CoroutineScope ,
useCase : MyProjectDebugPanelUseCase
) : ParentViewModel, VMDViewModelImpl(coroutineScope) {
override val debugPanel = DebugPanelViewModelImpl (
coroutineScope,
useCase,
useCase.createViewData( /* Configure the components here */ )
)
} Você pode controlar a visibilidade de cada componentes no parâmetro componentsVisibility da função createViewData() .
Exemplo:
useCase.createViewData(
/* ... */
componentsVisibility = flowOf(
MyProjectDebugPanelComponentsVisibility (
button1 = false ,
button2 = true ,
)
)
) Nesse caso, button1 será oculto e button2 será visível.
| Nome | Tipo de dados persistido | Configuração |
|---|---|---|
| DebugPaNELToggle | Boolean | Valor Boolean inicial |
| DebugPanellabel | - | Flow<String> |
| DebugPaneltextfield | String | Valor inicial String |
| DebugPanelbutton | - | Inicial () -> Unit |
| DebugPanelpicker | String | Valor inicial String representando o identificador de item selecionado |
| DebugPaneldatepicker | Long | Valor Long inicial representando a época em milissegundos |
| Enum | String | Valor da enumeração inicial |
O painel de depuração está configurado usando a anotação @DebugPanel(val prefix: String, val packageName: String) .
prefix está incluído no caso de uso gerado e classes de repositório.packageName é onde os arquivos serão emitidos dentro da pasta generated . Por padrão, os valores são salvos nas configurações usando seu nome de campo como identificador. No entanto, esse comportamento pode ser substituído usando a anotação @Identifier(val value: String) .
Para o Exemple, isso é útil no caso em que você deseja substituir um painel de depuração antigo por este e manter as teclas originais.
Exemplo:
@Identifier( " PREVIEW_MODE " )
val preview : DebugPanelToggle Por padrão, os componentes são exibidos ao lado de um rótulo com o nome do campo como valor. Você pode usar a anotação @DisplayName(val value: String) para dar aos componentes um rótulo mais significativo.
Exemplo:
@DisplayName( " Preview Mode " )
val preview : DebugPanelToggle Você pode usar a anotação @DebugProperty(val name: String) para gerar um componente que está vinculado a uma propriedade de classe.
Por exemplo, você pode ter um repositório com uma propriedade String ou Flow<String> e, colocando a anotação no campo, a biblioteca gerará uma propriedade delegada.
Você pode expor esse campo delegado na interface e o chamador receberá seu valor interno ou o do painel depuração (no caso em que ele é substituído).
Observe que esta anotação só pode ser usada com os tipos: String , Boolean , Enum , Flow<String> , Flow<Boolean> e Flow<Enum> .
Exemplo:
Repository.kt
interface Repository {
val value : Flow < String >
} RepositoryImpl.kt
class RepositoryImpl : Repository {
@Identifier( " custom_value_identifier " )
@DebugProperty( " value " )
val internalValue = flowOf( " String value " )
override val value by RepositoryImplValueDelegate
}Chamador:
val repository : Repository = RepositoryImpl ()
repository.value.map {
println ( " Repository value: $it " )
} Isso vai imprimir
Repository value: String value ou Repository value: Overridden value dependendo se Overridden value tiver sido inserido no campo de texto gerado.
O repositório gerado vem com um método resetSettings() que você pode chamar para limpar os valores de componentes persistentes. Esteja ciente de que os modelos de exibição do painel de depuração não estão vinculados a esses valores; portanto, você precisará sair da tela do painel de depuração ou matar o aplicativo para garantir que os valores sejam redefinidos corretamente (consulte RootViewModelImpl.kt na pasta de aplicativos de amostra).
O caso de uso gerado e as implementações do repositório têm o modificador open , o que significa que você pode estendê -los para adicionar mais funcionalidades, se necessário.
Se o seu projeto tiver uma biblioteca de injeção de dependência como o Koin e você tiver suas próprias classes estendidas, você poderá anotá -las com @Factory ou @Single .
Se você não precisar substituir essas classes, basta colocá -las manualmente nos módulos de injeção de dependências.
O painel de depuração é © 2013-2023 Mirego e pode ser distribuído livremente sob a nova licença BSD. Consulte o arquivo LICENSE.md .
Mirego é uma equipe de pessoas apaixonadas que acreditam que o trabalho é um lugar onde você pode inovar e se divertir. Somos uma equipe de pessoas talentosas que imaginam e constroem belos aplicativos móveis e web. Nos reunimos para compartilhar idéias e mudar o mundo.
Também adoramos software de código aberto e tentamos retribuir à comunidade o máximo que pudermos.
