1. shell adb
Algunas herramientas de línea de comandos comunes en adb shell:
pm : PackageManager, un administrador de paquetes, utilizado para administrar la instalación, desinstalación, consulta y más operaciones relacionadas de aplicaciones.
pm install…//
pm desinstalar…//
pm enumerar paquetes//Aplicaciones instaladas en el dispositivo
pm dump…//Obtener detalles de la aplicación, como nombre del paquete, número de versión, permisos, etc.
am : Administrador de actividades, administrador de actividades, utilizado para administrar las actividades en el dispositivo y el estado de las aplicaciones
am start…//
am stop…//
am force-stop…//
am broadcast //Enviar transmisión adb shell am broadcast -a com .example.myapp.CUSTOM_ACTION --es mensaje “¡Hola, mundo!” ——-un parámetro especifica la acción de transmisión (Acción), el parámetro –es se usa para agregar un valor de cadena adicional, la clave es mensaje, el valor es “ ¡Hola Mundo!"
adb: Android Debug Bridge es la principal herramienta de línea de comandos para comunicarse con dispositivos Android. Proporciona la capacidad de transferir archivos hacia y desde el dispositivo, depurar, instalar aplicaciones y realizar otras operaciones.
ls : El comando ls se utiliza para enumerar archivos y subdirectorios en un directorio. Por ejemplo, ls /sdcard enumera los archivos y directorios de la tarjeta de memoria del dispositivo (tarjeta SD).
cd : El comando cd se utiliza para cambiar el directorio de trabajo actual. Por ejemplo, cd /sdcard cambia el directorio actual a la tarjeta de memoria del dispositivo.
mkdir : el comando mkdir se utiliza para crear nuevos directorios. Por ejemplo, mkdir /sdcard/new_directory crea un nuevo directorio llamado "new_directory" en la tarjeta de memoria del dispositivo.
cp : El comando cp se utiliza para copiar archivos o directorios. Por ejemplo, cp /sdcard/file.txt /sdcard/backup/file.txt puede copiar el archivo llamado "file.txt" al directorio llamado "backup".
mv : El comando mv se usa para mover archivos o directorios y también se puede usar para cambiar el nombre de archivos o directorios. Por ejemplo, mv /sdcard/file.txt /sdcard/new_location/file_new.txt mueve el archivo a una nueva ubicación y le cambia el nombre a "file_new.txt".
rm : El comando rm se utiliza para eliminar archivos o directorios. Por ejemplo, rm /sdcard/file.txt puede eliminar el archivo llamado "file.txt", rm -f elimina el directorio de la carpeta
cat : El comando cat se utiliza para mostrar el contenido de un archivo. Por ejemplo, cat /sdcard/file.txt imprime el contenido del archivo en la interfaz de línea de comando.
chmod : el comando chmod se utiliza para cambiar los permisos de un archivo o directorio. Por ejemplo, chmod 755 /sdcard/file.txt cambia los permisos del archivo a 755.
2.json
Al analizar datos json, puede utilizar GSON (una biblioteca JSON de código abierto proporcionada por Google). Gson puede convertir objetos Java en cadenas JSON y cadenas JSON en objetos Java. Gson proporciona funciones más avanzadas y flexibilidad, como compatibilidad con reglas personalizadas de serialización y deserialización, manejo de relaciones de objetos complejas, formato de fechas, etc.
plugins {
id 'kotlin-parcelize'
}
依赖：
implementation "com.google.code.gson:gson:2.9.1"
Análisis de serialización:
@Parcelize
class ParsingObject(
@SerializedName("event_code")//统一编码格式，将json里的下划线转化为驼峰格式
val eventCode: Int = 10501,
@SerializedName("event_code")
val eventValue: Int,
val event: String = "DEFAULT_VALUE",//默认值
val params: FlightParams
) : Parcelable
jsonString
val gson = Gson()
val obj = gson.formJson<ParsingObject>(jsonString, ParsingObject::class.java)
然后解析相应对象即可
json内容是一个list
val info = gson.fromJson(jsonString, Array<ParsingObject>::class.java).toList()
当json内有pair对时，pair对数量未知，且value类型未知
"params":{
"key1":20,
"key2":"value",
"key3":true
}
@Parcelize
class ParseObject(val params : Map<String, @RawValue Any>) : Parcelable
jsonAnálisis de objetos:
//根据相应特征字段名获取
val jsonObject = JSONObject(jsonStr)
val jsonArray = jsonObject.getJSONArray("list")
val obj = jsonArray.getJSONObject(0)
val cityObj = obj.getJSONObject("cityInfo")
3. Lea los archivos en el directorio de activos.
Objeto AssetsManager
1.contexto
//获取AssetManager对象
val assetManager = context.assets
//InputStream 流
val inputStream: InputStream = assetManager.open("filename.txt")
//BufferedReader逐行读取
val reader = BufferedReader(InputStreamReader(inputStream))
var line: String?
while (reader.readLine().also {
line = it } != null) {
// 处理每一行的内容
}
//关闭
reader.close()
inputStream.close()
2.recursos
val assetManager = resources.assets
val inputStream: InputStream = assetManager.open("filename.txt")
3.Función de extensión de Kotlin
val assetManager = context.assets
val inputStream: InputStream = assetManager.open("filename.txt")
fun InputStream.readTextAndClose(charset: Charset = Charsets.UTF_8): String {
return this.bufferedReader(charset).use {
it.readText() }
}
val text: String = inputStream.readTextAndClose()
4. java spi
Idea central: SPI (interfaz de proveedor de servicios) desacoplada
es un mecanismo de descubrimiento de servicios integrado en JDK , que se puede utilizar para habilitar extensiones de marco y reemplazo de componentes.
1. Definir la interfaz y su clase de implementación.
public interface IFather{
...}
public class Son implements IFather{
...}
2. Cree un nuevo directorio META-INF/services en el directorio de recursos.
Cree un nuevo archivo en el directorio de servicios, el nombre del archivo es el directorio de la clase de interfaz y el contenido del archivo es la clase que se implementará.
Nombre del archivo: com.example.IFather
Contenido del archivo: com.example.Son
3.Cargar
ServiceLoader<IFather> s = ServiceLoader.load(IFather.class);
Iterator<IFather> it = s.iterator();
while(it.hasNext()) {
IFather c = it.next();
...
}
4. La clase de implementación debe llevar un constructor sin parámetros.
5. Anotación
1 anotación y 1 política de retención asociada.
1 anotación está asociada con 1 ~ n tipos de elementos.
La anotación tiene muchas clases de implementación, que incluyen: obsoleta, documentada, heredada, anulada, etc.
package java.lang.annotation;
public interface Annotation {
boolean equals(Object obj);
int hashCode();
String toString();
Class<? extends Annotation> annotationType();
}
package java.lang.annotation;
public enum ElementType {
TYPE, /* 类、接口（包括注释类型）或枚举声明 */
FIELD, /* 字段声明（包括枚举常量） */
METHOD, /* 方法声明 */
PARAMETER, /* 参数声明 */
CONSTRUCTOR, /* 构造方法声明 */
LOCAL_VARIABLE, /* 局部变量声明 */
ANNOTATION_TYPE, /* 注释类型声明 */
PACKAGE /* 包声明 */
}
@Target(ElementType.Type)//若有就表示用于指定的地方，若无则表示可用于任何地方
package java.lang.annotation;
public enum RetentionPolicy {
SOURCE, /* Annotation信息仅存在于编译器处理期间，编译器处理完之后就没有该Annotation信息了 */
CLASS, /* 编译器将Annotation存储于类对应的.class文件中。默认行为 */
RUNTIME /* 编译器将Annotation存储于class文件中，并且可由JVM读入 */
}
@Retention(RetentionPolicy.RUNTIME)//没有RetentionPolicy默认是CLASS
@Deprecated -- @Deprecated 所标注内容，不再被建议使用。
@Override -- @Override 只能标注方法，表示该方法覆盖父类中的方法。
@Documented -- @Documented 所标注内容，可以出现在javadoc中。
@Inherited -- @Inherited只能被用来标注“Annotation类型”，它所标注的Annotation具有继承性。
@Retention -- @Retention只能被用来标注“Annotation类型”，而且它被用来指定Annotation的RetentionPolicy属性。
@Target -- @Target只能被用来标注“Annotation类型”，而且它被用来指定Annotation的ElementType属性。
@SuppressWarnings -- @SuppressWarnings 所标注内容产生的警告，编译器会对这些警告保持静默。
Un ejemplo:
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.PARAMETER)
public @interface ServiceFunctionParameters {
String NO_DEFAULT_VALUE = "OPEServiceFunctionParameters_NO_INPUT_PROVIDED";
String description() default "";
String name();
String defaultValue() default NO_DEFAULT_VALUE;
boolean required() default true;
Class<?> type() default String.class;
}
fun addCalendarSchedule(
@ServiceFunctionParameters(
name = "title",
description = "你需要根据该日程主题给拟一个标题"
) title: String?,
@ServiceFunctionParameters(
name = "description",
description = "日程的具体内容"
) description: String?,
@ServiceFunctionParameters(
name = "startTime",
description = "日程开始时间,格式：yyyy-MM-dd HH:mm:ss"
) startTime: String?,
@ServiceFunctionParameters(
name = "endTime",
description = "日程结束时间,格式：yyyy-MM-dd HH:mm:ss"
) endTime: String?,
) {
...}
6. Genéricos
1. Métodos genéricos
Todas las declaraciones de métodos genéricos tienen una sección de declaración de parámetros de tipo (delimitada por corchetes angulares) que precede al tipo de retorno del método.
Cada parte de la declaración de parámetros de tipo contiene uno o más parámetros de tipo, separados por comas. Un parámetro genérico, también llamado variable de tipo, es un identificador que especifica el nombre de un tipo genérico.
Los parámetros de tipo se pueden utilizar para declarar tipos de valores de retorno y pueden servir como marcadores de posición para los tipos de parámetros reales obtenidos mediante métodos genéricos.
La declaración del cuerpo de un método genérico es la misma que para otros métodos. Tenga en cuenta que los parámetros de tipo solo pueden representar tipos de referencia, no tipos primitivos (como int, double, char, etc.).
public class GenericMethod {
//泛型方法
public static <E> void printArray( E[] inputArray ) {
// 输出数组元素
for ( E element : inputArray ) {
System.out.printf( "%s ", element );
}
System.out.println();
}
public static void main( String args[] ) {
// 创建不同类型数组： Integer, Double 和 Character
Integer[] intArray = {
1, 2, 3, 4, 5 };
Double[] doubleArray = {
1.1, 2.2, 3.3, 4.4 };
Character[] charArray = {
'H', 'E', 'L', 'L', 'O' };
System.out.println( "整型数组元素为:" );
printArray( intArray ); // 传递一个整型数组
System.out.println( "\n双精度型数组元素为:" );
printArray( doubleArray ); // 传递一个双精度型数组
System.out.println( "\n字符型数组元素为:" );
printArray( charArray ); // 传递一个字符型数组
}
}
整型数组元素为:
1 2 3 4 5
双精度型数组元素为:
1.1 2.2 3.3 4.4
字符型数组元素为:
H E L L O
2. Clases genéricas
La declaración de una clase genérica es similar a la declaración de una clase no genérica, excepto que se agrega una parte de declaración de parámetro de tipo después del nombre de la clase. Al igual que el método genérico, la parte de declaración de parámetro de tipo de la clase genérica también contiene uno o más parámetros de tipo Parámetros Sepárelos con comas. Un parámetro genérico, también conocido como variable de tipo, es un identificador que se utiliza para especificar el nombre de un tipo genérico. Debido a que aceptan uno o más parámetros, estas clases se denominan clases parametrizadas o tipos parametrizados.
public class Box<T> {
private T t;
public void add(T t) {
this.t = t;
}
public T get() {
return t;
}
public static void main(String[] args) {
Box<Integer> integerBox = new Box<Integer>();
Box<String> stringBox = new Box<String>();
integerBox.add(new Integer(10));
stringBox.add(new String("测试"));
System.out.printf("整型值为 :%d\n\n", integerBox.get());//整型值为 :10
System.out.printf("字符串为 :%s\n", stringBox.get());//字符串为 :测试
}
}
3. Escriba comodín
Generalmente se utilizan comodines de tipo en lugar de parámetros de tipo específicos
import java.util.*;
public class GenericTest {
public static void main(String[] args) {
List<String> name = new ArrayList<String>();
List<Integer> age = new ArrayList<Integer>();
List<Number> number = new ArrayList<Number>();
name.add("icon");
age.add(18);
number.add(314);
getData(name);//data :icon
getData(age);//data :18
getData(number);//data :314
}
public static void getData(List<?> data) {
System.out.println("data :" + data.get(0));
}
}
El límite superior de comodines de tipo está definido por? extiende Clase, es decir, solo puede ser Clase o sus subclases
import java.util.*;
public class GenericTest {
public static void main(String[] args) {
List<String> name = new ArrayList<String>();
List<Integer> age = new ArrayList<Integer>();
List<Number> number = new ArrayList<Number>();
name.add("icon");
age.add(18);
number.add(314);
//getUperNumber(name);//String非Number的子类
getUperNumber(age);//
getUperNumber(number);//
}
public static void getUperNumber(List<? extends Number> data) {
System.out.println("data :" + data.get(0));
}
}
El límite superior del comodín de tipo está definido por ?superClass, es decir, solo puede ser Clase y su tipo principal superior, como objeto
7. Programación monoresponsiva
Programación asincrónica, procesamiento de lógica que requiere mucho tiempo. mono se utiliza para manejar secuencias asincrónicas que contienen cero o un elemento.
val mono = Mono.fromCallable{
......//耗时逻辑
}
mono.subscribe{
result ->
Log.d(TAG,"....")
}//只有subscribe这里订阅了，fromCallable里的耗时逻辑才会执行
val mono = Mono.just{
...
}
同样需要订阅
//让耗时逻辑在子线程中执行
mono.subscribeOn(Schedulers.Parallel())
mono.subscribeOn(Schedulers.boundedElastic())