Configuração avançada do Gradle

Others 2021-01-23 06:32:02 views: null

1. Dois modos e configuração de assinatura do Android Studio

modo de depuração

O modo de depuração usa um debug.keystore padrão para assinatura.

Esta assinatura padrão (keystore) não requer uma senha. Seu local padrão é C: \ Users \ <username> \. Android \ debug.keystore, se não existir, o Android Studio irá criá-la automaticamente.

Por exemplo, meu debug.keystore está em C: \ Users \ Administrator \ .android \ debug.keystore.

 

modo de liberação

Você não pode usar debug.keystore quando lançarmos oficialmente o projeto. Durante o processo de desenvolvimento, também podemos usar o modo de liberação para executar. Pode ser definido da seguinte forma:

BuildVariants-Build Variant-debug / release

Se o projeto precisar subdividir as versões de desenvolvimento dev e produção pro, cada versão contém modos de depuração e liberação, você pode defini-la assim:

É subdividido em quatro modos:

O modo de liberação precisa ser configurado com uma assinatura para ser executado, então um keystore é necessário

Caso contrário, você precisa criá-lo. Se você já criou um armazenamento de chaves, pule esta etapa

 

1. Crie um keystore e gere nosso apk (empacotado)

 A primeira etapa: Construir --- >> Gerar APK assinado

Etapa 2: Criar Novo ··· ( Escolha Escolher existente ··· para o keystore que foi criado )

Etapa 3: preencha as informações relevantes

Definir caminho de armazenamento de chaves, senha, definir chave: alias, senha, período de validade, certificado, etc.

Caminho de armazenamento de chaves: caminho de armazenamento

Chave

　　Alias: alias

　　Validade (anos): período de validade (geralmente padrão 25 anos)

　　Certificado: Certificado

　　　　Nome e Sobrenome ： 姓名

　　　　Unidade Organizacional: Unidade Organizacional

　　　　Organização: Organização

　　　　Cidade ou localidade: cidade ou região

　　　　Estado ou Província: Estado ou Província

　　　　Código do país (XX): Código do país (XX), China: 86

 

Etapa 4: insira a chave e a senha do keystore

Etapa 5: selecione o caminho para lançar o aplicativo, o método de lançamento pode ser selecionado por padrão

OK, o lançamento foi bem sucedido, você pode encontrar o apk lançado na pasta de destino que acabou de definir

 

Para algumas pessoas, isso é muito complicado. Você deve inserir informações relevantes sempre e fazer escolhas. Existe uma maneira mais simples e rápida? A resposta é sim.

Podemos configurar a assinatura em build.gradle no diretório do aplicativo do projeto. 

2. Configure o armazenamento de chaves no modo de liberação

Assinatura da estrutura do projeto, insira as informações do keystore criado

Os tipos de construção precisam ser configurados para que a assinatura tenha efeito

Clique em OK e verifique se o arquivo de configuração correspondente a build.gradle deve ter esta aparência. Claro, você também pode escrever o parágrafo a seguir diretamente no build.gradle.

Copiar código

1 SignatureConfigs { 
 2 release { 
 3 keyAlias'androiddebugkey ' 
 4 keyPassword'android' 
 5 storeFile file ('C: /Users/ssc/.android/debug.keystore') 
 6 storePassword'android ' 
 7} 
 8} 
 9 
10 ··· ······ 
11 
12 buildTypes { 
13 release { 
              // Se deve ser confundido 
14 minifyEnabled false 
              // Se deve remover recursos inúteis 
15 zipAlignEnabled true 
              // Arquivo de configuração confuso 
16 proguardFiles getDefaultProguardFile ('proguard-android.txt'), ' proguard-rules.pro '
17 assinaturaConfig assinaturaConfigs.release 
18} 
19}

Copiar código

 

Embora a configuração acima seja simples, ela é insegura. Se o seu projeto for de código aberto e você escrever informações como a senha de configuração do arquivo de assinatura no build.gradle em texto simples, é muito inseguro?

Você pode escrever informações como a senha de configuração do arquivo de assinatura diretamente em local.properties, porque no projeto de controle de versão Git , podemos ver que existe um arquivo .gitignore no diretório raiz do nosso modo de projeto. A configuração dentro é mais ou menos como segue

Podemos ver /local.properties, o que significa que local.properties não é adicionado ao controle de versão por padrão, porque local.properties armazena algumas informações relevantes sobre os recursos de nosso ambiente, como o caminho do SDK. Portanto, podemos configurar as informações de assinatura em local.properties sem nos preocupar com vazamento de chave. Para projetos de código aberto, é muito bom.

Adicione informações relevantes diretamente em local.properties

No build.gradle, para não exibir em texto simples, devemos primeiro obter a configuração relevante da chave, para que possamos no build.gradle do aplicativo

Adicionar código no Android {}

Copiar código

1 def keystoreFilepath = '' 
 2 def keystorePSW = '' 
 3 def keystoreAlias ​​= '' 
 4 def keystoreAliasPSW = '' 
 5 // arquivo keystore padrão, caminho do arquivo de configuração PLZ em local.properties 
 6 def keyfile = file ('s.keystore. temp ') 
 7 
 8 Propriedades properties = new Properties () 
 9 // arquivo local.properties no diretório raiz 
10 properties.load (project.rootProject.file (' local.properties '). newDataInputStream ()) 
11 keystoreFilepath = properties. getProperty ("keystore.path") 
12 
13 if (keystoreFilepath) { 
14 keystorePSW = properties.getProperty ("keystore.password") 
15 keystoreAlias ​​= properties.getProperty ("keystore.de outros ")
16 keystoreAliasPSW = properties.getProperty ("keystore.alias_password") 
17 keyfile = arquivo (keystoreFilepath) 
18}

Copiar código

Ver código

A assinaturaConfigs em app / build.gradle pode ser alterada para:

?

1

2

3

4

5

6

7

8

signingConfigs {

       release {

           keyAlias keystoreAlias

           keyPassword keystoreAliasPSW

           storeFile keyfile

           storePassword keystorePSW

       }

   }

　　

Não há necessidade de se preocupar com o valor do keystore na assinatura após a configuração

Da mesma forma, buildTypes também podem ser configurados assim

Copiar código

1 buildTypes { 
 2 release { 
 3 minifyEnabled false 
 4 proguardFiles getDefaultProguardFile ('proguard-android.txt'), 'proguard-rules.pro' 
 5 // subscriptionConfig eatingConfigs.release 
 6 // 签名 文件 存在 ， 则 签名
 7 if (keyfile. existe ()) { 
 8 println ("WITH -> buildTypes -> release: using jks key") 
 9 signatureConfig eatingConfigs.release 
10} else { 
11 println ("WITH -> buildTypes -> release: using default key") 
12} 
13 23} 
24}

Copiar código

Neste ponto, a configuração anterior está concluída.

 

Anexo: consulte as informações relevantes do armazenamento de chaves, como visualizar o valor de sha1; você pode localizar o caminho onde o armazenamento de chaves está localizado na janela de execução e executar cd C: \ Usuários \ ssc \ .android

Depois de executar essa instrução, todas as informações da chave podem ser exibidas (pegue o armazenamento de chaves padrão do Android como exemplo)

keytool -list -v -keystore xxx.jks

Se você quiser configurar os modos de liberação e depuração de maneira uniforme, use o keystore lançado oficialmente

android { 
    SignConfigs { 
        config { 
            keyAlias ​​'myalias' 
            keyPassword 'mypswd' 
            storeFile file ("./ keystore / ***. jks") 
            storePassword '******' 
        } 
    } 
    buildTypes { 
        release { 
            debuggable false 
            minifyEnabled true //启用 Proguard 
            shrinkResources true // 是否 清理 无用 资源, 依赖 于 minifyEnabled 
            useProguard true 
            subscriptionConfig eatingConfigs.config 
            proguardFiles getDefaultProguardFile ('proguard-android.txt'), 'proguard-rules.pro' 
        } 
        debug {
            debuggable verdadeira 
            minifyEnabled true // Ativar Proguard 
            shrinkResources true // Se deve limpar os recursos inúteis, depende minifyEnabled 
            useProguard verdadeira 
            signingConfig signingConfigs.config 
            proguardFiles getDefaultProguardFile ( 'proguard-android.txt'), 'proguard-rules.pro' 
        } 
    }

2. Embalagem multicanal

O papel da embalagem multicanal: apk - publique no mercado (o canal é onde você pode baixar o apk)

1.0: apk publicado em diferentes canais, marcando diferentes canais, o objetivo é contar o volume de download, taxa de retenção e outros dados do canal

2.0: Compreenda os downloads

3.0: Publicidade direcionada

Se você não empacota em vários canais, e um pacote apk é colocado em dezenas de mercados, como você sabe qual mercado tem o maior volume de download - multicanal é principalmente para operação

Vamos falar sobre vários métodos de empacotamento multicanal.

O primeiro tipo: embalagem multicanal Youmeng

Como líder da plataforma de três partidos, Youmeng tem muitas rodas excelentes. O Youmeng Statistics pode detectar os canais de download de APK, fazer estatísticas e investir em seus próximos passos com base em excelentes canais.

Não há muito a dizer, basta ir ao código:

1. Primeiro, adicione AndroidManifest:

 

android:name="UMENG_CHANNEL"
android:value="${UMENG_CHANNEL_VALUE}"

2. Em seguida, adicione-o em build.gradle, baidu {} é a abreviatura do nome do canal especificado:

 

 productFlavors { 
   baidu {}
   xiaomi {}
   qihu360 {}
   yingyongbao {}
   huawei {}
 } 
 productFlavors.all {
   flavor -> flavor.manifestPlaceholders = [UMENG_CHANNEL_VALUE: name]
}

3. Adicione o número da versão por trás do APK:

Versão do Android Studio 2.3:

 

 applicationVariants.all { variant ->
         variant.outputs.each { output ->
             def outputFile = output.outputFile
             if (outputFile != null && outputFile.name.endsWith('.apk')) {
                 def fileName = "driver_${variant.productFlavors[0].name}_v${defaultConfig.versionName}.apk" 
                 output.outputFile = new File(outputFile.parent, fileName)
             }
         }
     }

Versão do Android Studio 3.0:

 

flavorDimensions 'api' productFlavors {
    ... }
    android.applicationVariants.all { variant ->
         variant.outputs.all {
            outputFileName = "driver_${variant.productFlavors[0].name}_v${variant.versionName}.apk"
        }
    }

4. Em seguida, adicionarei um método para obter o número do canal na interface de introdução do APP pela primeira vez e carregá-lo nos parâmetros.

 

private String getChannel() {
    try {
        PackageManager pm = getPackageManager();
        ApplicationInfo appInfo = pm.getApplicationInfo(getPackageName(), PackageManager.GET_META_DATA);
        return appInfo.metaData.getString("UMENG_CHANNEL");
      } catch (PackageManager.NameNotFoundException ignored) {
    }
    return "";
}

5. Faça as malas e fique online:

imagem

Desvantagens: Obviamente, as desvantagens são incômodas e nojentas.

O segundo tipo: embalagem multicanal Meituan Walle

Depois que o Android 7.0 lançou o novo esquema de assinatura do aplicativo APK Signature Scheme v2, o método anterior de geração rápida de pacotes de canais não funcionava mais. Então, lançou a ferramenta de pacote de canal mais recente Walle ( endereço do artigo )

A ferramenta de geração de pacotes de canais de nova geração é totalmente baseada no formato de arquivo ZIP e formato de armazenamento APK Signing Block. É processado com base no fluxo binário do arquivo. Tem boa velocidade de processamento e compatibilidade e pode atender aos requisitos de diferentes idiomas A ferramenta consiste principalmente em quatro partes:

1. Biblioteca de classe Java para escrever informações de valor de ID

2. O plugin de compilação do Gradle é usado para integração com o processo de empacotamento do Android

3. Biblioteca de classe Java para ler informações de valor de ID

4. AAR usado para ler as informações do canal para com.android.application

Dessa forma, você só precisa copiar um APK para cada pacote de canal e, em seguida, adicionar um valor de ID ao APK. Este método de empacotamento é muito rápido e leva apenas mais de 100 milissegundos para um pacote APK de 30M (incluindo o arquivo tempo de cópia) Pode gerar um pacote de canal e leva apenas alguns milissegundos para obter informações do canal em tempo de execução.

Operação basica:

 

1、配置根build.gradle：
 buildscript {
   dependencies {
         classpath 'com.meituan.android.walle:plugin:1.1.6'
    }
}

2. Configure o App build.gradle:

 

applyplugin:'walle'
  dependencies {
  compile'com.meituan.android.walle:library:1.1.6'
}

3. Configure o plug-in

 

walle {
//指定渠道包的输出路径
apkOutputFolder=newFile("${project.buildDir}/outputs/channels");
//定制渠道包的APK的文件名称
apkFileNameFormat='${appName}-${packageName}-${channel}-${buildType}-v${versionName}-${versionCode}-${buildTime}.apk';
//渠道配置文件
channelFile=newFile("${project.getProjectDir()}/channel")}

Explicação específica dos itens de configuração:

apkOutputFolder: especifique o caminho de saída do pacote do canal, o valor padrão é new File ("$ {project.buildDir} / outputs / apk")

apkFileNameFormat: O nome do arquivo do APK do pacote de canal personalizado, o valor padrão é '$ {appName} - $ {buildType} - $ {channel} .apk'

As seguintes variáveis ​​podem ser usadas:

 

projectName - 项目名字

appName - App模块名字

packageName - applicationId (App包名packageName)

buildType - buildType (release/debug等)

channel - channel名称 (对应渠道打包中的渠道名字)

versionName - versionName (显示用的版本号)

versionCode - versionCode (内部版本号)

buildTime - buildTime (编译构建日期时间)

fileSHA1 - fileSHA1 (最终APK文件的SHA1哈希值)

flavorName - 编译构建 productFlavors 名

channelFile：包含渠道配置信息的文件路径。 具体内容格式详见：[渠道配置文件示例](https://github.com/Meituan-Dianping/walle/blob/master/app/channel)，支持使用#号添加注释。

4. Obtenha informações do canal:

 

Stringchannel=WalleChannelReader.getChannel(this.getApplicationContext());

5. Gerar pacote de canal:

Digite na linha de comando do Terminal:

./gradlew clean assembleReleaseChannels

Algumas contas em execução são escritas, a melhor postagem do blog é o documento oficial

Por favor, veja o documento oficial para detalhes

O terceiro tipo: VasDolly multicanal de código aberto Tencent

Para obter detalhes, consulte o Blog da Boutique Hongyang Great God

Quarto: ferramenta de embalagem de três partes (recomendado)

Link: https://pan.baidu.com/s/1dTsq7cZq8kqFbql-KhutuQ Senha: 3zu7

Instruções:

1. Copie o APK a ser empacotado no diretório raiz

2. Adicione ou modifique a lista de canais no arquivo de canais

3. Execute o arquivo publish.exe

Configurações de código:

 

compile 'com.meituan.android.walle:library:1.0.5'

 

 ChannelInfo channelInfo = WalleChannelReader.getChannelInfo(getApplicationContext());
 String channelName = channelInfo.getChannel();  (渠道名称)
 Map<String, String> extraInfo = channelInfo.getExtraInfo();  (额外信息)

Muito rápido, simples e conveniente, me apaixonei por embalagens

Existem muitos métodos de empacotamento, mas são todos iguais. É importante compreender os princípios. Vale a pena aprender e refletir sobre um entendimento profundo da assinatura do Android e do formato de arquivo ZIP.

 

Três, configuração unificada do Gradle

Aqui, observamos a diferença entre
build.gradle no diretório do aplicativo: build.gradle no diretório do aplicativo é: apply plugin: com.android.application

O build.gradle na biblioteca de módulos é: apply plugin: com.android.library

A outra é que a versão é diferente e os elementos são os mesmos. Aqui está o que vamos apresentar hoje. Aqui, vemos que a versão compilada do SDK, a versão compilada das ferramentas e a versão mínima que suporta o SDK têm versões diferentes números. Mesmo, aqui precisamos unificar, e nem sempre podemos configurar manualmente todas as vezes, é fácil cometer erros quando o Módulo aumenta

Solução:

Método 1: Execute a configuração unificada em build.gradle no diretório raiz do projeto da seguinte maneira

 

  1. /*在根目录中配置公用供子模块调用*/

  2. ext {

  3. //Android

  4. compileSdkVersion = 25

  5. buildToolsVersion = "25.0.2"

  6. minSdkVersion = 15

  7. targetSdkVersion = 25

  8.  

  9. //Version

  10. supportLibrary = "25.1.0"

  11.  

  12. //supportLibraries dependencies

  13. supportDependencies = [

  14. supportAppcompat: "com.android.support:appcompat-v7:${supportLibrary}",

  15. ]

  16. }

O build.gradle do diretório raiz do projeto após a configuração:

 

  1. //构建脚本

  2. buildscript {

  3.  

  4. repositories {

  5.  

  6. //依赖的仓库

  7. jcenter()

  8. }

  9. dependencies {

  10.  

  11. //项目依赖的Gradle版本

  12. classpath 'com.android.tools.build:gradle:2.2.3'

  13.  

  14. // NOTE: Do not place your application dependencies here; they belong

  15. // in the individual module build.gradle files

  16. }

  17. }

  18.  

  19. allprojects {

  20. repositories {

  21. jcenter()

  22. }

  23. }

  24.  

  25. task clean(type: Delete) {

  26. delete rootProject.buildDir

  27. }

  28.  

  29. /*在根目录中配置公用供子模块调用*/

  30. ext {

  31. //Android

  32. compileSdkVersion = 25

  33. buildToolsVersion = "25.0.2"

  34. minSdkVersion = 15

  35. targetSdkVersion = 25

  36.  

  37. //Version

  38. supportLibrary = "25.1.0"

  39.  

  40. //supportLibraries dependencies

  41. supportDependencies = [

  42. supportAppcompat: "com.android.support:appcompat-v7:${supportLibrary}",

  43. ]

  44. }

Em seguida, chamamos o build.gradle do aplicativo da seguinte maneira:

 

  1. apply plugin: 'com.android.application'

  2.  

  3. android {

  4.  

  5. compileSdkVersion rootProject.ext.compileSdkVersion

  6. buildToolsVersion rootProject.ext.buildToolsVersion

  7.  

  8. defaultConfig {

  9.  

  10. applicationId "com.example.qiudengjiao.activitytest"

  11. minSdkVersion rootProject.ext.minSdkVersion

  12. targetSdkVersion rootProject.ext.targetSdkVersion

  13. versionCode 1

  14. versionName "1.0"

  15. testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"

  16. }

  17.  

  18. buildTypes {

  19. release {

  20. minifyEnabled false

  21. proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'

  22. }

  23. }

  24. }

  25.  

  26. dependencies {

  27. compile fileTree(include: ['*.jar'], dir: 'libs')

  28. androidTestCompile('com.android.support.test.espresso:espresso-core:2.2.2', {

  29. exclude group: 'com.android.support', module: 'support-annotations'

  30. })

  31. compile 'junit:junit:4.12'

  32. compile rootProject.ext.supportDependencies.supportAppcompat

  33. }

  34.  

A chamada é feita no build.gradle do Module da seguinte maneira:

 

  1. apply plugin: 'com.android.library'

  2.  

  3. android {

  4.  

  5. compileSdkVersion rootProject.ext.compileSdkVersion

  6. buildToolsVersion rootProject.ext.buildToolsVersion

  7.  

  8. defaultConfig {

  9.  

  10. minSdkVersion rootProject.ext.minSdkVersion

  11. targetSdkVersion rootProject.ext.targetSdkVersion

  12. versionCode 1

  13. versionName "1.0"

  14.  

  15. testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"

  16.  

  17. }

  18.  

  19. buildTypes {

  20. release {

  21. minifyEnabled false

  22. proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'

  23. }

  24. }

  25. }

  26.  

  27. dependencies {

  28. compile fileTree(dir: 'libs', include: ['*.jar'])

  29. androidTestCompile('com.android.support.test.espresso:espresso-core:2.2.2', {

  30. exclude group: 'com.android.support', module: 'support-annotations'

  31. })

  32. testCompile 'junit:junit:4.12'

  33.  

  34. compile rootProject.ext.supportDependencies.supportAppcompat

  35. }

  36.  

Desta forma, concluímos o uso do Gradle para resolver a configuração unificada do build.gradle no aplicativo no projeto e a dependência build.gradle no Módulo do projeto. Por analogia, mais Módulos são configurados no mesmo forma. Só precisamos mudar a versão no futuro. Vá para o diretório raiz build.gradle e modifique-o

Método Dois

Como todos têm seus próprios hábitos de configuração, aqui fornecemos outra configuração para sua referência. Aqui, criamos config.gradle no diretório raiz do projeto principal para configurar as informações de configuração necessárias da seguinte maneira:

Informações de configuração em config.gradle:

 

  1. /**

  2. * 在主项目的根目录下创建config.gradle文件

  3. * 在这里单独处理统一依赖问题

  4. * 注意需要在根目录的build.gradle中进行引入

  5. */

  6. ext {

  7. android = [

  8. compileSdkVersion: 25,

  9. buildToolsVersion: "25.0.2",

  10. minSdkVersion : 15,

  11. targetSdkVersion : 25

  12. ]

  13.  

  14. //Version

  15. supportLibrary = "25.1.0"

  16.  

  17. //supportLibraries dependencies

  18. supportDependencies = [

  19. supportAppcompat: "com.android.support:appcompat-v7:${supportLibrary}",

  20. supportV4 : "com.android.support:support-v4:${supportLibrary}",

  21. suppoutDesign : "com.android.support:design:${supportLibrary}"

  22. ]

  23. }

Em seguida, precisamos importar config.gradle no build.gradle do diretório raiz e prestar atenção especial aqui à introdução de build.gradle no diretório raiz

apply from: "config.gradle"

O diretório raiz importado build.gradle é o seguinte:

A seguir, podemos apresentá-lo e usá-lo no Módulo, da seguinte maneira:

 

  1. apply plugin: 'com.android.library'

  2.  

  3. //android配置

  4. def config = rootProject.ext.android

  5.  

  6. //相关库依赖

  7. def librarys = rootProject.ext.supportDependencies

  8. android {

  9. compileSdkVersion config.compileSdkVersion

  10. buildToolsVersion config.buildToolsVersion

  11.  

  12. defaultConfig {

  13. minSdkVersion config.minSdkVersion

  14. targetSdkVersion config.targetSdkVersion

  15. versionCode 1

  16. versionName "1.0"

  17.  

  18. testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"

  19.  

  20. }

  21. buildTypes {

  22. release {

  23. minifyEnabled false

  24. proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'

  25. }

  26. }

  27. }

  28.  

  29. dependencies {

  30. compile fileTree(dir: 'libs', include: ['*.jar'])

  31. androidTestCompile('com.android.support.test.espresso:espresso-core:2.2.2', {

  32. exclude group: 'com.android.support', module: 'support-annotations'

  33. })

  34. testCompile 'junit:junit:4.12'

  35.  

  36. //在这里使用库的依赖

  37. compile librarys.supportAppcompat

  38. compile librarys.supportV4

  39. compile librarys.suppoutDesign

  40. }

Neste ponto, apresentamos com sucesso o build.gradle do Módulo. A introdução de cada Módulo será assim. Ele desempenha a mesma função do Método 1. Pessoalmente, acho que o segundo método é melhor. Você pode escolhê-lo sozinho Afinal, cada um tem seus próprios méritos, ok, aqui vou compartilhar com vocês o uso de dependências de configuração unificada do Gradle no projeto, espero que seja útil para todos

 

Quatro, ferramenta de plug-in do Android Studio

Plug-ins recomendados para melhorar a eficiência do desenvolvimento

1 、 GsonFormat

2 、 Butterknife / Gerador de código Android

3 、 Gerar seletores Android

Nota: Ao mesmo tempo, não é adequado instalar muitos plug-ins para evitar o consumo excessivo de memória e causar atraso.

 

Cinco, ferramentas de inspeção de código e análise de desempenho

1. Ferramenta de inspeção de código - Android Lint

2. Ferramenta de análise de desempenho - Monitor

 

 

 

 

 

 

 

 

 

 

Acho que você gosta

Origin blog.csdn.net/MYBOYER/article/details/105164701
Recomendado
Clasificación
Diario
Más
2024-06-05(0)
2024-06-04(0)
2024-06-03(0)
2024-06-02(0)
2024-06-01(0)
2024-05-31(0)
2024-05-30(0)
2024-05-29(0)
2024-05-28(0)
2024-05-27(0)

Code World

© 2018 codetd.com