Posted on | In

官网：HDC常见命令

全局option相关命令

Option 说明
-t [key] [command] 指定连接唯一标识的目标设备。标识可通过命令hdc list targets查询。
help/-h 打印hdc帮助信息。
version/-v 打印hdc版本信息。
-l [level] 指定运行时日志等级，默认为LOG_INFO。
checkserver 获取client-server版本。
Read more »

Posted on | In

基础入门

ArkTS工程目录结构（Stage模型）

  • AppScope > app.json5：应用的全局配置信息，详见app.json5配置文件。【不能放ets文件。模块的ets中引用它编译通不过无法预览但可以运行。可在资源文件中引用AppScope中的资源】
  • entry：HarmonyOS工程模块，编译构建生成一个HAP包。
    • src > main > ets：用于存放ArkTS源码。
    • src > main > ets > entryability：应用/服务的入口。
    • src > main > ets > entrybackupability：应用提供扩展的备份恢复能力。
    • src > main > ets > pages：应用/服务包含的页面。
    • src > main > resources：用于存放应用/服务所用到的资源文件，如图形、多媒体、字符串、布局文件等。关于资源文件，详见资源分类与访问。
    • src > main > module.json5：模块配置文件。主要包含HAP包的配置信息、应用/服务在具体设备上的配置信息以及应用/服务的全局配置信息。具体的配置文件说明，详见module.json5配置文件。
    • build-profile.json5：当前的模块信息 、编译信息配置项，包括buildOption、targets配置等。【不同字段模块级的buildOption配置会继承工程级配置】
    • hvigorfile.ts：模块级编译构建任务脚本。
    • obfuscation-rules.txt：混淆规则文件。混淆开启后，在使用Release模式进行编译时，会对代码进行编译、混淆及压缩处理，保护代码资产。详见开启代码混淆。
    • oh-package.json5：用来描述包名、版本、入口文件（类型声明文件）和依赖项等信息。
  • oh_modules：用于存放三方库依赖信息。
  • build-profile.json5：工程级配置信息，包括签名signingConfigs、产品配置products等。其中products中可配置当前运行环境，默认为HarmonyOS。
  • hvigorfile.ts：工程级编译构建任务脚本。
  • oh-package.json5：主要用来描述全局配置，如：依赖覆盖（overrides）、依赖关系重写（overrideDependencyMap）和参数化配置（parameterFile）等。
Read more »

Posted on | In

新历转农历

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
package com.xm597.common;  
  
import java.text.ParseException;  
import java.text.SimpleDateFormat;  
import java.util.Calendar;  
import java.util.Date;  
  
public class LunarCalendar {  
    private int year;// 农历年  
    private int month;// 农历月  
    private int day;// 农历日  
    private boolean leap;// 农历闰年  
    // 上面4个值在构造方法中根据传入日期计算所得  
  
    /**  
     * 中文月名称  
     */  
    final static String chineseNumber[] = { "一", "二", "三", "四", "五", "六", "七", "八", "九", "十", "十一", "十二" };  
    /**  
     * 中文日期格式  
     */  
    static SimpleDateFormat chineseDateFormat = new SimpleDateFormat("yyyy年MM月dd日");  
    /**  
     * 农历数据， 1901 ~ 2100 年之间正确  
     */  
    final static long[] lunarInfo = new long[] { 0x04bd8, 0x04ae0, 0x0a570, 0x054d5, 0x0d260, 0x0d950, 0x16554,  
            0x056a0, 0x09ad0, 0x055d2, 0x04ae0, 0x0a5b6, 0x0a4d0, 0x0d250, 0x1d255, 0x0b540, 0x0d6a0, 0x0ada2, 0x095b0,  
            0x14977, 0x04970, 0x0a4b0, 0x0b4b5, 0x06a50, 0x06d40, 0x1ab54, 0x02b60, 0x09570, 0x052f2, 0x04970, 0x06566,  
            0x0d4a0, 0x0ea50, 0x06e95, 0x05ad0, 0x02b60, 0x186e3, 0x092e0, 0x1c8d7, 0x0c950, 0x0d4a0, 0x1d8a6, 0x0b550,  
            0x056a0, 0x1a5b4, 0x025d0, 0x092d0, 0x0d2b2, 0x0a950, 0x0b557, 0x06ca0, 0x0b550, 0x15355, 0x04da0, 0x0a5d0,  
            0x14573, 0x052d0, 0x0a9a8, 0x0e950, 0x06aa0, 0x0aea6, 0x0ab50, 0x04b60, 0x0aae4, 0x0a570, 0x05260, 0x0f263,  
            0x0d950, 0x05b57, 0x056a0, 0x096d0, 0x04dd5, 0x04ad0, 0x0a4d0, 0x0d4d4, 0x0d250, 0x0d558, 0x0b540, 0x0b5a0,  
            0x195a6, 0x095b0, 0x049b0, 0x0a974, 0x0a4b0, 0x0b27a, 0x06a50, 0x06d40, 0x0af46, 0x0ab60, 0x09570, 0x04af5,  
            0x04970, 0x064b0, 0x074a3, 0x0ea50, 0x06b58, 0x055c0, 0x0ab60, 0x096d5, 0x092e0, 0x0c960, 0x0d954, 0x0d4a0,  
            0x0da50, 0x07552, 0x056a0, 0x0abb7, 0x025d0, 0x092d0, 0x0cab5, 0x0a950, 0x0b4a0, 0x0baa4, 0x0ad50, 0x055d9,  
            0x04ba0, 0x0a5b0, 0x15176, 0x052b0, 0x0a930, 0x07954, 0x06aa0, 0x0ad50, 0x05b52, 0x04b60, 0x0a6e6, 0x0a4e0,  
            0x0d260, 0x0ea65, 0x0d530, 0x05aa0, 0x076a3, 0x096d0, 0x04bd7, 0x04ad0, 0x0a4d0, 0x1d0b6, 0x0d250, 0x0d520,  
            0x0dd45, 0x0b5a0, 0x056d0, 0x055b2, 0x049b0, 0x0a577, 0x0a4b0, 0x0aa50, 0x1b255, 0x06d20, 0x0ada0 };  
  
    // ====== 传回农历 y年的总天数  
    final private static int yearDays(int y) {  
        int i, sum = 348;  
        for (i = 0x8000; i > 0x8; i >>= 1) {  
            if ((lunarInfo[y - 1900] & i) != 0)  
                sum += 1;  
        }  
        return (sum + leapDays(y));  
    }  
  
    // ====== 传回农历 y年闰月的天数  
    final private static int leapDays(int y) {  
        if (leapMonth(y) != 0) {  
            if ((lunarInfo[y - 1900] & 0x10000) != 0)  
                return 30;  
            else  
                return 29;  
        } else  
            return 0;  
    }  
  
    // ====== 传回农历 y年闰哪个月 1-12 , 没闰传回 0    final private static int leapMonth(int y) {  
        return (int) (lunarInfo[y - 1900] & 0xf);  
    }  
  
    // ====== 传回农历 y年m月的总天数  
    final private static int monthDays(int y, int m) {  
        if ((lunarInfo[y - 1900] & (0x10000 >> m)) == 0)  
            return 29;  
        else  
            return 30;  
    }  
  
    // ====== 传回农历 y年的生肖  
    final public String animalsYear() {  
        final String[] Animals = new String[] { "鼠", "牛", "虎", "兔", "龙", "蛇", "马", "羊", "猴", "鸡", "狗", "猪" };  
        return Animals[(year - 4) % 12];  
    }  
  
    // ====== 传入 月日的offset 传回干支, 0=甲子  
    final private static String cyclicalm(int num) {  
        final String[] Gan = new String[] { "甲", "乙", "丙", "丁", "戊", "己", "庚", "辛", "壬", "癸" };  
        final String[] Zhi = new String[] { "子", "丑", "寅", "卯", "辰", "巳", "午", "未", "申", "酉", "戌", "亥" };  
        return (Gan[num % 10] + Zhi[num % 12]);  
    }  
  
    // ====== 传入 offset 传回干支, 0=甲子  
    final public String cyclical() {  
        int num = year - 1900 + 36;  
        return (cyclicalm(num));  
    }  
  
  
  
    /**  
     * 构造一个表示当前日期的农历日历  
     */  
    public LunarCalendar() {  
        this(Calendar.getInstance());  
    }  
  
    /**  
     * 构造一个表示指定日期的农历日历  
     */  
    public LunarCalendar(Date date) {  
        this(date2calendar(date));  
    }  
  
    private static Calendar date2calendar(Date date) {  
        Calendar tmpCale = Calendar.getInstance();  
        tmpCale.setTime(date);  
        return tmpCale;  
    }  
  
    /**  
     * 使用指定日历日期构造一个农历日历  
     *  
     * @param cal  
     */  
    public LunarCalendar(Calendar cal) {  
        @SuppressWarnings("unused")  
        int yearCyl, monCyl, dayCyl;  
        int leapMonth = 0;  
        Date baseDate = null;  
        try {  
            baseDate = chineseDateFormat.parse("1900年1月31日");  
        } catch (ParseException e) {  
        }  
  
        // 求出和1900年1月31日相差的天数  
        int offset = (int) ((cal.getTime().getTime() - baseDate.getTime()) / 86400000L);  
        dayCyl = offset + 40;  
        monCyl = 14;  
  
        // 用offset减去每农历年的天数  
        // 计算当天是农历第几天  
        // i最终结果是农历的年份  
        // offset是当年的第几天  
        int iYear, daysOfYear = 0;  
        for (iYear = 1900; iYear < 2050 && offset > 0; iYear++) {  
            daysOfYear = yearDays(iYear);  
            offset -= daysOfYear;  
            monCyl += 12;  
        }  
        if (offset < 0) {  
            offset += daysOfYear;  
            iYear--;  
            monCyl -= 12;  
        }  
        // 农历年份  
        year = iYear;  
  
        yearCyl = iYear - 1864;  
        leapMonth = leapMonth(iYear); // 闰哪个月,1-12  
        leap = false;  
  
        // 用当年的天数offset,逐个减去每月（农历）的天数，求出当天是本月的第几天  
        int iMonth, daysOfMonth = 0;  
        for (iMonth = 1; iMonth < 13 && offset > 0; iMonth++) {  
            // 闰月  
            if (leapMonth > 0 && iMonth == (leapMonth + 1) && !leap) {  
                --iMonth;  
                leap = true;  
                daysOfMonth = leapDays(year);  
            } else{  
                daysOfMonth = monthDays(year, iMonth);  
            }  
  
            offset -= daysOfMonth;  
            // 解除闰月  
            if (leap && iMonth == (leapMonth + 1)){  
                leap = false;  
            }  
            if (!leap){  
                monCyl++;  
            }  
        }  
        // offset为0时，并且刚才计算的月份是闰月，要校正  
        if (offset == 0 && leapMonth > 0 && iMonth == leapMonth + 1) {  
            if (leap) {  
                leap = false;  
            } else {  
                leap = true;  
                --iMonth;  
                --monCyl;  
            }  
        }  
        // offset小于0时，也要校正  
        if (offset < 0) {  
            offset += daysOfMonth;  
            --iMonth;  
            --monCyl;  
        }  
        month = iMonth;  
        day = offset + 1;  
    }  
  
    /**  
     * 获得表示农历年月日的日期对象  
     *  
     * @return     */    public Date getDate() {  
        Calendar calendar = Calendar.getInstance();  
        calendar.set(Calendar.YEAR, year);  
        calendar.set(Calendar.MONTH, month - 1);  
        calendar.set(Calendar.DAY_OF_MONTH, day);  
        return calendar.getTime();  
    }  
  
    public static String getChinaDayString(int day) {  
        String chineseTen[] = { "初", "十", "廿", "卅" };  
        int n = day % 10 == 0 ? 9 : day % 10 - 1;  
        if (day > 30)  
            return "";  
        if (day == 10)  
            return "初十";  
        else  
            return chineseTen[day / 10] + chineseNumber[n];  
    }  
  
    public String toString() {  
        return year + "年" + (leap ? "闰" : "") + chineseNumber[month - 1] + "月" + getChinaDayString(day);  
    }  
}

调用：

Read more »

Posted on | In

深入理解Java并发之synchronized实现原理

线程安全是并发编程中的重要关注点，应该注意到的是，造成线程安全问题的主要诱因有两点，一是存在共享数据(也称临界资源)，二是存在多条线程共同操作共享数据。因此为了解决这个问题，我们可能需要这样一个方案，当存在多个线程操作共享数据时，需要保证同一时刻有且只有一个线程在操作共享数据，其他线程必须等到该线程处理完数据后再进行，这种方式有个高尚的名称叫互斥锁，即能达到互斥访问目的的锁，也就是说当一个共享数据被当前正在访问的线程加上互斥锁后，在同一个时刻，其他线程只能处于等待的状态，直到当前线程处理完毕释放该锁。在 Java 中，关键字 synchronized可以保证在同一个时刻，只有一个线程可以执行某个方法或者某个代码块(主要是对方法或者代码块中存在共享数据的操作)，同时我们还应该注意到synchronized另外一个重要的作用，synchronized可保证一个线程的变化(主要是共享数据的变化)被其他线程所看到（保证可见性，完全可以替代Volatile功能），这点确实也是很重要的。

synchronized的三种应用方式

Read more »

Posted on | In

什么是AOSP

AOSP是一个由谷歌维护的开源操作系统开发项目。AOSP涵盖了操作系统内的一系列软件层，为硬件和应用开发者提供接入点和工具。

image-20230914175049315

Read more »