1. ADB-Shell
Einige gängige Befehlszeilentools unter der ADB-Shell:
pm : PackageManager, ein Paketmanager, der zum Verwalten der Installation, Deinstallation, Abfrage und weiterer verwandter Vorgänge von Anwendungen verwendet wird.
pm install …//
pm uninstall …//
pm Pakete auflisten//Installierte Anwendungen auf dem Gerät
pm dump…//Anwendungsdetails abrufen, wie Paketname, Versionsnummer, Berechtigungen usw.
am : Aktivitätsmanager, Aktivitätsmanager, der zum Verwalten von Aktivitäten auf dem Gerät und des Status von Anwendungen verwendet
wird .example.myapp.CUSTOM_ACTION --es message „Hello, World!“ ——-ein Parameter gibt die Broadcast-Aktion (Action) an, –es-Parameter wird verwendet, um einen zusätzlichen String-Wert hinzuzufügen, der Schlüssel ist message, der Wert ist „ Hallo Welt!"
adb: Android Debug Bridge ist das wichtigste Befehlszeilentool für die Kommunikation mit Android-Geräten. Es bietet die Möglichkeit, Dateien vom und zum Gerät zu übertragen, Fehler zu beheben, Anwendungen zu installieren und andere Vorgänge auszuführen.
ls : Der Befehl ls wird verwendet, um Dateien und Unterverzeichnisse in einem Verzeichnis aufzulisten. Beispielsweise listet ls /sdcard die Dateien und Verzeichnisse auf der Speicherkarte (SD-Karte) des Geräts auf.
cd : Der Befehl cd wird verwendet, um das aktuelle Arbeitsverzeichnis zu ändern. Beispielsweise ändert cd /sdcard das aktuelle Verzeichnis auf die Gerätespeicherkarte.
mkdir : Der Befehl mkdir wird zum Erstellen neuer Verzeichnisse verwendet. Beispielsweise erstellt mkdir /sdcard/new_directory ein neues Verzeichnis mit dem Namen „new_directory“ auf der Gerätespeicherkarte.
cp : Der Befehl cp wird zum Kopieren von Dateien oder Verzeichnissen verwendet. Beispielsweise kann cp /sdcard/file.txt /sdcard/backup/file.txt die Datei mit dem Namen „file.txt“ in das Verzeichnis mit dem Namen „backup“ kopieren.
mv : Der Befehl mv wird zum Verschieben von Dateien oder Verzeichnissen verwendet und kann auch zum Umbenennen von Dateien oder Verzeichnissen verwendet werden. Beispielsweise verschiebt mv /sdcard/file.txt /sdcard/new_location/file_new.txt die Datei an einen neuen Speicherort und benennt sie in „file_new.txt“ um.
rm : Der Befehl rm wird zum Löschen von Dateien oder Verzeichnissen verwendet. Beispielsweise kann rm /sdcard/file.txt die Datei mit dem Namen „file.txt“ löschen, rm -f löscht das Ordnerverzeichnis
cat : Der Befehl cat wird verwendet, um den Inhalt einer Datei anzuzeigen. Beispielsweise gibt cat /sdcard/file.txt den Inhalt der Datei an die Befehlszeilenschnittstelle aus.
chmod : Der Befehl chmod wird verwendet, um die Berechtigungen einer Datei oder eines Verzeichnisses zu ändern. Beispielsweise ändert chmod 755 /sdcard/file.txt die Berechtigungen der Datei auf 755.
2.json
Beim Parsen von JSON-Daten können Sie GSON (eine von Google bereitgestellte Open-Source-JSON-Bibliothek) verwenden. Gson kann Java-Objekte in JSON-Strings und JSON-Strings in Java-Objekte konvertieren. Gson bietet erweiterte Funktionen und Flexibilität, z. B. die Unterstützung benutzerdefinierter Serialisierungs- und Deserialisierungsregeln, die Handhabung komplexer Objektbeziehungen, Datumsformatierung usw.
plugins {
id 'kotlin-parcelize'
}
依赖：
implementation "com.google.code.gson:gson:2.9.1"
Serialisierungsanalyse:
@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
jsonObject-Analyse:
//根据相应特征字段名获取
val jsonObject = JSONObject(jsonStr)
val jsonArray = jsonObject.getJSONArray("list")
val obj = jsonArray.getJSONObject(0)
val cityObj = obj.getJSONObject("cityInfo")
3. Lesen Sie die Dateien im Assets-Verzeichnis
AssetsManager-Objekt
1.Kontext
//获取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. Ressourcen
val assetManager = resources.assets
val inputStream: InputStream = assetManager.open("filename.txt")
3. Kotlin-Erweiterungsfunktion
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
Kernidee: Entkoppeltes
SPI (Service Provider Interface) ist ein im JDK integrierter Service-Discovery-Mechanismus , mit dem Framework-Erweiterungen und Komponentenaustausch ermöglicht werden können.
1. Definieren Sie die Schnittstelle und ihre Implementierungsklasse
public interface IFather{
...}
public class Son implements IFather{
...}
2. Erstellen Sie ein neues META-INF/services-Verzeichnis unter dem Ressourcenverzeichnis.
Erstellen Sie eine neue Datei im Diensteverzeichnis. Der Dateiname ist das Verzeichnis der Schnittstellenklasse und der Dateiinhalt ist die zu implementierende Klasse.
Dateiname: com.example.IFather
Dateiinhalt: com.example.Son
3.Laden
ServiceLoader<IFather> s = ServiceLoader.load(IFather.class);
Iterator<IFather> it = s.iterator();
while(it.hasNext()) {
IFather c = it.next();
...
}
4. Die Implementierungsklasse muss einen Konstruktor ohne Parameter enthalten
5. Anmerkung
1 Anmerkung und 1 RetentionPolicy zugeordnet.
1 Anmerkung ist mit 1~n ElementTypes verknüpft.
Annotation verfügt über viele Implementierungsklassen, darunter: Veraltet, Dokumentiert, Geerbt, Überschreiben usw.
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 所标注内容产生的警告，编译器会对这些警告保持静默。
Ein Beispiel:
@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. Generika
1. Generische Methoden
Alle generischen Methodendeklarationen verfügen über einen Abschnitt zur Typparameterdeklaration (getrennt durch spitze Klammern), der dem Rückgabetyp der Methode vorangeht.
Jeder Typparameter-Deklarationsteil enthält einen oder mehrere durch Kommas getrennte Typparameter. Ein generischer Parameter, auch Typvariable genannt, ist ein Bezeichner, der den Namen eines generischen Typs angibt.
Typparameter können zum Deklarieren von Rückgabewerttypen verwendet werden und als Platzhalter für die tatsächlichen Parametertypen dienen, die von generischen Methoden erhalten werden.
Die Deklaration eines generischen Methodenkörpers ist dieselbe wie bei anderen Methoden. Beachten Sie, dass Typparameter nur Referenztypen darstellen können, keine primitiven Typen (wie int, double, char usw.).
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. Generische Klassen
Die Deklaration einer generischen Klasse ähnelt der Deklaration einer nicht generischen Klasse, mit der Ausnahme, dass nach dem Klassennamen ein Typparameter-Deklarationsteil hinzugefügt wird. Wie die generische Methode enthält auch der Typparameter-Deklarationsteil der generischen Klasse ein oder Weitere Typparameter. Parameter Trennen Sie sie durch Kommas. Ein generischer Parameter, auch Typvariable genannt, ist ein Bezeichner, der zur Angabe des Namens eines generischen Typs verwendet wird. Da sie einen oder mehrere Parameter akzeptieren, werden diese Klassen als parametrisierte Klassen oder parametrisierte Typen bezeichnet.
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. Geben Sie Platzhalter ein
Anstelle spezifischer Typparameter werden im Allgemeinen Typplatzhalter verwendet
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));
}
}
Die Obergrenze für Typ-Wildcards wird durch ? Extends Class definiert, das heißt, es kann nur Class oder seine Unterklassen sein
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));
}
}
Die Obergrenze des Typplatzhalters wird durch ? superClass definiert, d. h. es kann sich nur um Class und seinen oberen übergeordneten Typ handeln, z
7. Mono-responsive Programmierung
Asynchrone Programmierung, Verarbeitung zeitaufwändiger Logik. mono wird verwendet, um asynchrone Sequenzen zu verarbeiten, die null oder ein Element enthalten.
val mono = Mono.fromCallable{
......//耗时逻辑
}
mono.subscribe{
result ->
Log.d(TAG,"....")
}//只有subscribe这里订阅了，fromCallable里的耗时逻辑才会执行
val mono = Mono.just{
...
}
同样需要订阅
//让耗时逻辑在子线程中执行
mono.subscribeOn(Schedulers.Parallel())
mono.subscribeOn(Schedulers.boundedElastic())