Configuración avanzada de Gradle

Others 2021-01-23 06:31:55 views: null

1. Dos modos y configuración de firma de Android Studio

modo de depuración

El modo de depuración utiliza un debug.keystore predeterminado para firmar.

Esta firma predeterminada (almacén de claves) no requiere contraseña. Su ubicación predeterminada es C: \ Users \ <nombre de usuario> \. Android \ debug.keystore, si no existe, Android Studio la creará automáticamente.

Por ejemplo, mi debug.keystore está en C: \ Users \ Administrator \ .android \ debug.keystore.

 

modo de liberación

No puede usar debug.keystore cuando lanzamos oficialmente el proyecto. Durante el proceso de desarrollo, también podemos usar el modo de lanzamiento para ejecutar. Se puede configurar de la siguiente manera:

BuildVariants-Build Variant-debug / release

Si el proyecto necesita subdividir las versiones de desarrollo y producción profesional, cada versión contiene modos de depuración y lanzamiento, puede configurarlo así:

Se subdivide en cuatro modos:

El modo de lanzamiento debe configurarse con una firma para ejecutarse, luego se necesita un almacén de claves

De lo contrario, debe crearlo. Si ya ha creado un almacén de claves, omita este paso.

 

1. Cree un almacén de claves y genere nuestro apk (empaquetado)

 El primer paso: compilar --- >> Generar APK firmado

Paso 2: Crear nuevo ··· ( Elija Elegir existente ··· para el almacén de claves que se ha creado )

Paso 3: Complete la información relevante

Establezca la ruta del almacén de claves, la contraseña, la clave establecida: alias, contraseña, período de validez, certificado, etc.

Ruta del almacén de claves: ruta de almacenamiento

Llave

　　Alias: alias

　　Validez (años): período de validez (generalmente por defecto 25 años)

　　Certificado: Certificado

　　　　Nombre y apellido: 姓名

　　　　Unidad organizativa: Unidad organizativa

　　　　Organización: Organización

　　　　Ciudad o localidad: Ciudad o región

　　　　Estado o provincia: Estado o provincia

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

 

Paso 4: Ingrese la clave, contraseña del almacén de claves

Paso 5: seleccione la ruta para lanzar la aplicación, el método de lanzamiento se puede seleccionar de forma predeterminada

OK, el lanzamiento es exitoso, puede encontrar el apk publicado en la carpeta de destino que acaba de configurar

 

Para algunas personas, esto es demasiado engorroso. Tienes que ingresar información relevante cada vez y tomar decisiones. ¿Existe una manera más simple y rápida? La respuesta es sí.

Podemos configurar la firma en build.gradle en el directorio de aplicaciones del proyecto. 

2. Configurar el almacén de claves en modo de liberación

Firma de la estructura del proyecto, ingrese la información del almacén de claves creado

Los tipos de compilación deben configurarse para que la firma surta efecto

Haga clic en Aceptar y luego verifique que el archivo de configuración correspondiente a build.gradle debería verse así. Por supuesto, también puede escribir el siguiente párrafo directamente en build.gradle.

Copiar codigo

1 signingConfigs { 
 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 { 
              // Si confundir 
14 minifyEnabled false 
              // Si eliminar recursos inútiles 
15 zipAlignEnabled true 
              // Archivo de configuración confuso 
16 proguardFiles getDefaultProguardFile ('proguard-android.txt'), ' proguard-rules.pro ' 
17 signingConfig signingConfigs.release 
18} 
19}

Copiar codigo

 

Aunque la configuración anterior es simple, es insegura. Si su proyecto es de código abierto y escribe información como la contraseña de configuración del archivo de firma en build.gradle en texto plano, ¿es muy inseguro?

Puede escribir información como la contraseña de configuración del archivo de firma directamente en local.properties, porque en el proyecto de control de versiones de Git , podemos ver que hay un archivo .gitignore en el directorio raíz de nuestro modo de proyecto. La configuración interna es aproximadamente como sigue

Podemos ver /local.properties, lo que significa que local.properties no se agrega al control de versiones de forma predeterminada, porque local.properties almacena información relevante sobre los recursos de nuestro entorno, como la ruta del SDK. Por lo tanto, podemos configurar la información de la firma en local.properties sin preocuparnos por la fuga de claves. Para proyectos de código abierto, es muy bueno.

Agregue información relevante directamente debajo de local.properties

En build.gradle, para que no se muestre en texto plano, primero debemos obtener la configuración relevante de la clave, para que podamos en la aplicación build.gradle

Agregar código en Android {}

Copiar codigo

1 def keystoreFilepath = '' 
 2 def keystorePSW = '' 
 3 def keystoreAlias ​​= '' 
 4 def keystoreAliasPSW = '' 
 5 // archivo de almacén de claves predeterminado, ruta del archivo de configuración PLZ en local.properties 
 6 def keyfile = file ('s.keystore. temp ') 
 7 
 8 Propiedades properties = new Properties () 
 9 // Archivo local.properties en el director raíz 
10 properties.load (project.rootProject.file (' local.properties '). newDataInputStream ()) 
11 keystoreFilepath = propiedades. getProperty ("keystore.path") 
12 
13 if (keystoreFilepath) { 
14 keystorePSW = properties.getProperty ("keystore.password") 
15 keystoreAlias ​​= properties.getProperty ("keystore.otro ")
16 keystoreAliasPSW = properties.getProperty ("keystore.alias_password") 
17 keyfile = file (keystoreFilepath) 
18}

Copiar codigo

Ver código

El signingConfigs en app / build.gradle se puede cambiar a:

?

1

2

3

4

5

6

7

8

signingConfigs {

       release {

           keyAlias keystoreAlias

           keyPassword keystoreAliasPSW

           storeFile keyfile

           storePassword keystorePSW

       }

   }

　　

No es necesario preocuparse por el valor del almacén de claves en la firma después de la configuración

En consecuencia, buildTypes también se puede configurar así

Copiar codigo

1 buildTypes { 
 2 release { 
 3 minifyEnabled false 
 4 proguardFiles getDefaultProguardFile ('proguard-android.txt'), 'proguard-rules.pro' 
 5 // signingConfig signingConfigs.release 
 6 // 签名 文件 存在 ， 则 签名
 7 if (keyfile. existe ()) { 
 8 println ("CON -> buildTypes -> lanzamiento: usando la clave jks") 
 9 signingConfig signingConfigs.release 
10} else { 
11 println ("CON -> buildTypes -> lanzamiento: usando la clave predeterminada") 
12} 
13 23} 
24}

Copiar codigo

En este punto, la configuración anterior está completa.

 

Adjunto: consulte la información relevante del almacén de claves, como ver el valor de sha1; puede ubicar la ruta donde se encuentra el almacén de claves en la ventana de ejecución y ejecutar cd C: \ Users \ ssc \ .android

Después de ejecutar esta declaración, se puede mostrar toda la información de la clave (tome el almacén de claves predeterminado de Android como ejemplo)

keytool -list -v -keystore xxx.jks

Si desea configurar los modos de liberación y depuración de manera uniforme, use el almacén de claves lanzado oficialmente

android { 
    signingConfigs { 
        config { 
            keyAlias ​​'myalias' 
            keyPassword 'mypswd' 
            storeFile file ("./ keystore / ***. jks") 
            storePassword '******' 
        } 
    } 
    buildTypes { 
        release { 
            debuggable false 
            minifyEnabled true //启用 Proguard 
            shrinkResources true // 是否 清理 无用 资源, 依赖 于 minifyEnabled 
            useProguard true 
            signingConfig signingConfigs.config 
            proguardFiles getDefaultProguardFile ('proguard-android.txt'), 'proguard-rules.pro' 
        } 
        debug {
            debuggable true 
            minifyEnabled true // Habilita Proguard 
            shrinkResources true // Ya sea para limpiar recursos inútiles, depende de minify 
            Habilitado useProguard true 
            signingConfig signingConfigs.config 
            proguardFiles getDefaultProguardFile ('proguard-android.txt'), 'proguard-rules.pro' 
        } 
    }

2. Embalaje multicanal

El papel del empaque multicanal: apk - publicar en el mercado (el canal es donde puede descargar el apk)

1.0: apk publicado en diferentes canales, marcando diferentes canales, el propósito es contar el volumen de descarga, tasa de retención y otros datos del canal

2.0: comprender las descargas

3.0: publicidad dirigida

Si no empaqueta en varios canales y un paquete apk se coloca en docenas de mercados, ¿cómo puede saber qué mercado tiene el mayor volumen de descarga? El multicanal es principalmente para operaciones.

Hablemos de varios métodos de empaquetado multicanal.

El primer tipo: embalaje multicanal de Youmeng

Como líder de la plataforma tripartita, Youmeng tiene muchas ruedas excelentes. Youmeng Statistics puede detectar los canales de descarga de APK, hacer estadísticas e invertir en sus próximos pasos basados ​​en excelentes canales.

No hay mucho que decir, solo ve al código:

1. Primero, agregue AndroidManifest:

 

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

2. A continuación, agréguelo en build.gradle, baidu {} es la abreviatura del nombre del canal especificado:

 

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

3. Agregue el número de versión detrás del APK:

Versión de 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)
             }
         }
     }

Versión de 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. A continuación, agregaré un método para obtener el número de canal en la interfaz de introducción de la APLICACIÓN por primera vez y lo cargaré a los 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. Empaque y conéctese en línea:

imagen

Desventajas: obviamente, las desventajas son engorrosas y repugnantes.

El segundo tipo: embalaje multicanal Meituan Walle

Después de que Android 7.0 lanzara el nuevo esquema de firmas de aplicaciones APK Signature Scheme v2, el método anterior de generar rápidamente paquetes de canales dejó de funcionar. Así que lanzó la última herramienta de paquete de canales Walle ( dirección del artículo )

La herramienta de generación de paquetes de canales de nueva generación se basa completamente en el formato de archivo ZIP y el formato de almacenamiento APK Signing Block. Se procesa en base al flujo binario del archivo. Tiene buena velocidad de procesamiento y compatibilidad y puede cumplir con los requisitos de diferentes idiomas. La herramienta principalmente Hay cuatro partes:

1. Biblioteca de clases Java para escribir información de valor de ID

2. El complemento de compilación de Gradle se utiliza para integrarse con el proceso de empaquetado de Android

3. Biblioteca de clases Java para leer información de valor de ID

4. AAR utilizado para leer la información del canal para com.android.application

De esta manera, solo necesita copiar un APK para cada paquete de canal y luego agregar un valor de ID al APK. Este método de empaquetado es muy rápido y solo toma más de 100 milisegundos para un paquete APK de 30M (incluido el archivo tiempo de copia) Puede generar un paquete de canales, y solo se necesitan unos pocos milisegundos para obtener información del canal en tiempo de ejecución.

Operación básica:

 

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

2. Configure la aplicación build.gradle:

 

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

3. Configure el complemento

 

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

Explicación específica de los elementos de configuración:

apkOutputFolder: especifique la ruta de salida del paquete del canal, el valor predeterminado es nuevo Archivo ("$ {project.buildDir} / outputs / apk")

apkFileNameFormat: el nombre de archivo del APK del paquete de canal personalizado, el valor predeterminado es '$ {appName} - $ {buildType} - $ {channel} .apk'

Se pueden utilizar las siguientes variables:

 

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. Obtén información del canal:

 

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

5. Generar paquete de canales:

Ingrese en la línea de comando de Terminal:

./gradlew clean ensamblarReleaseChannels

Algunas cuentas en ejecución están escritas, la mejor publicación de blog es el documento oficial.

Consulte el documento oficial para obtener más detalles.

El tercer tipo: VasDolly multicanal de código abierto Tencent

Para obtener más información, consulte el blog de Hongyang Great God Boutique

Cuarto: herramienta de empaquetado tripartita (recomendada)

Enlace: https://pan.baidu.com/s/1dTsq7cZq8kqFbql-KhutuQ Contraseña: 3zu7

Instrucciones:

1. Copie el APK que se empaquetará en el directorio raíz.

2. Agregue o modifique la lista de canales en el archivo de canales.

3. Ejecute el archivo publish.exe

Configuración 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();  (额外信息)

Muy rápido, simple y conveniente, me enamoré del empaque

Hay muchos métodos de empaquetado, pero todos son iguales. Es importante comprender los principios. Vale la pena aprender y reflexionar sobre una comprensión profunda de la firma de Android y el formato de archivo ZIP.

 

Tres, configuración unificada de Gradle

Aquí vemos la diferencia entre
build.gradle en el directorio de la aplicación: build.gradle en el directorio de la aplicación es: apply plugin: com.android.application

El build.gradle bajo la biblioteca de módulos es: apply plugin: com.android.library

La otra es que la versión es diferente y los elementos son los mismos. Esto es lo que vamos a presentar hoy. Aquí vemos que la versión compilada del SDK, la versión compilada de Herramientas y la versión mínima que soporta el SDK tienen una versión diferente. Igual, aquí necesitamos unificar, y no siempre podemos configurar manualmente cada vez, es fácil cometer errores cuando el Módulo aumenta

Solución:

Método 1: realice la configuración unificada en build.gradle en el directorio raíz del proyecto de la siguiente manera

 

  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. }

El build.gradle del directorio raíz del proyecto después de la configuración:

 

  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. }

A continuación, invocamos build.gradle de la aplicación de la siguiente manera:

 

  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.  

La llamada se realiza en el build.gradle del Módulo de la siguiente manera:

 

  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.  

De esta forma, hemos completado el uso de Gradle para resolver la configuración unificada del build.gradle bajo la aplicación en el proyecto y la dependencia build.gradle en el Módulo en el proyecto. Por analogía, se configuran más Módulos en el mismo manera. Solo necesitamos cambiar la versión en el futuro. Vaya al directorio raíz build.gradle y modifíquelo

Método dos

Debido a que todos tienen sus propios hábitos de configuración, aquí proporcionamos otra configuración para su referencia. Aquí creamos config.gradle en el directorio raíz del proyecto principal para configurar la información de configuración requerida de la siguiente manera:

Información de configuración en 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. }

Luego, necesitamos importar config.gradle en build.gradle del directorio raíz y prestar especial atención aquí a la introducción de build.gradle en el directorio raíz.

apply from: "config.gradle"

El directorio raíz importado build.gradle es el siguiente:

A continuación, podemos introducirlo y usarlo en Module, de la siguiente manera:

 

  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. }

En este punto, nos hemos introducido con éxito en el build.gradle del Módulo. La introducción de cada Módulo será así. Realiza la misma función que el Método 1. Personalmente, creo que el segundo método es mejor. Puede elegirlo usted mismo Después de todo, cada uno tiene sus propios méritos, está bien, aquí compartiré con ustedes el uso de las dependencias de configuración unificada de Gradle en el proyecto, espero que sea de utilidad para todos

 

Cuatro, herramienta de complemento de Android Studio

Complementos recomendados para mejorar la eficiencia del desarrollo

1 、 GsonFormat

2 、 Butterknife / Generador de código Android

3 、 Generar selectores de Android

Nota: Al mismo tiempo, no es adecuado instalar demasiados complementos para evitar un consumo excesivo de memoria y provocar retrasos.

 

Cinco, herramientas de análisis de rendimiento e inspección de código

1. Herramienta de inspección de código: Android Lint

2. Herramienta de análisis del rendimiento: monitor

 

 

 

 

 

 

 

 

 

 

Supongo que te gusta

Origin blog.csdn.net/MYBOYER/article/details/105164701
Recomendado
Clasificación
Diario
Más
2024-04-25(34)
2024-04-24(31)
2024-04-23(29)
2024-04-22(5)
2024-04-21(0)
2024-04-20(6)
2024-04-19(5)
2024-04-18(0)
2024-04-17(30)
2024-04-16(22)

Code World

© 2018 codetd.com