Android?應用程序的啟動流程示例詳解
應用進程的啟動流程
本文基于Android 11，主要分析應用程序的啟動流程，會直接定位到ActivityStackSupervisor.startSpecificActivity函數(shù)開始，因為該函數(shù)前面的內(nèi)容主要在Activity的啟動流程中，可以通過這部分的文章來閱讀。
看源碼流程，需要戒驕戒躁，心態(tài)好。配合源碼使用，建議先收藏，夜深人靜，心血來潮再看。
通過分析應用進程的啟動流程，可以得到：
- 在Framework層，現(xiàn)在不止有AMS負責請求Zygote進程創(chuàng)建新進程，還有ATMS、ActivityStarter、ActivityTaskManger、ActivityTaskS在協(xié)助分擔一些參數(shù)和邏輯的檢查。
- 每個進程都是通過fork Zygote進程而來，且獲得Java虛擬機。也就是說每一個應用進程都有自己的虛擬機。
- 應用進程是通過Soket去請求Zygote進程fork自己的。
- 每個進程都有自己的Binder線程池用于IPC。
- 每個應用進程的主線程在ActivityThread,其main函數(shù)會創(chuàng)建消息循環(huán)機制。
1、ActivityStackSupervisor.startSpecificActivity
ATMS有一個ProcessMap<WindowProcessController>類型的mProcessNames ,用于存儲封裝了已啟動進程信息ProcessRecord和窗口信息Windows的WindowProcessController實例。WindowProcessController用于協(xié)調(diào)ActivityManger管理ProcessReocrd和WindwManger管理WIndow和Activity的關系。
void startSpecificActivity(ActivityRecord r, boolean andResume, boolean checkConfig) {
// Is this activity's application already running?
final WindowProcessController wpc =
mService.getProcessController(r.processName, r.info.applicationInfo.uid);
boolean knownToBeDead = false;
if (wpc != null && wpc.hasThread()) {
realStartActivityLocked(r, wpc, andResume, checkConfig);
return;
...
knownToBeDead = true;
}
r.notifyUnknownVisibilityLaunchedForKeyguardTransition();
final boolean isTop = andResume && r.isTopRunningActivity();
mService.startProcessAsync(r, knownToBeDead, isTop, isTop ? "top-activity" : "activity");
}
這里的mService是ActivityTaskManagerService的實例，通過getProcessController函數(shù)獲得當前wpc對象，判斷當前啟動應用進程是否啟動wpc != null && wpc.hasThread(),如果條件成立，則開始真正啟動一個未啟動過的Activity,通過realStartActivityLocked；條件不成立，則調(diào)用mService的startProcessAsync啟動當前Activity的所在的進程。即startSpecificActivity函數(shù)是啟動進程和啟動Activity的一個分界點。
2、ATMS.startProcessAsync
PooledLambda.obtainMessage函數(shù)是Lambda的調(diào)用方式，表示調(diào)用ActivityManagerInternal的startProcess函數(shù)，后續(xù)則是其參數(shù)。并返回一個Message對象，發(fā)給Handler類型的mH。
void startProcessAsync(ActivityRecord activity, boolean knownToBeDead, boolean isTop,
String hostingType) {
final Message m = PooledLambda.obtainMessage(ActivityManagerInternal::startProcess,
mAmInternal, activity.processName, activity.info.applicationInfo, knownToBeDead,
isTop, hostingType, activity.intent.getComponent());
mH.sendMessage(m);
}
抽象類ActivityManagerInternal的繼承類定義在ActivityManagerService的內(nèi)部類LocalService。
public final class LocalService extends ActivityManagerInternal
3、LocalService.startProcess
@Override
public void startProcess(String processName, ApplicationInfo info, boolean knownToBeDead,
boolean isTop, String hostingType, ComponentName hostingName) {
startProcessLocked(processName, info, knownToBeDead, 0 /* intentFlags */,
new HostingRecord(hostingType, hostingName, isTop),
ZYGOTE_POLICY_FLAG_LATENCY_SENSITIVE, false /* allowWhileBooting */,
false /* isolated */, true /* keepIfLarge */);
}
4、startProcessLocked函數(shù)
final ProcessRecord startProcessLocked(String processName,
ApplicationInfo info, boolean knownToBeDead, int intentFlags,
HostingRecord hostingRecord, int zygotePolicyFlags, boolean allowWhileBooting,
boolean isolated, boolean keepIfLarge) {
return mProcessList.startProcessLocked(processName, info, knownToBeDead, intentFlags,
hostingRecord, zygotePolicyFlags, allowWhileBooting, isolated, 0 /* isolatedUid */,
keepIfLarge, null /* ABI override */, null /* entryPoint */,
null /* entryPointArgs */, null /* crashHandler */);
}
5、ProcessList.startProcessLocked
ProcessList類的startProcessLocked函數(shù)，有幾個重載函數(shù)，第一個調(diào)用。
在 ！isolated，判斷了啟動IntentFlag是否后臺運行，是的話，直接拒絕。否則清理AMS中發(fā)生過Crash的進程（當前應用）。
分析一：創(chuàng)立當前應用進程的描述ProcessRecord。
判斷當前系統(tǒng)是否啟動完畢，未啟動完畢，將進程信息緩存到AMS的mProcessesOnHold中。
分析二：調(diào)用了另外一個重載函數(shù)。
final ProcessRecord startProcessLocked(String processName, ApplicationInfo info,
boolean knownToBeDead, int intentFlags, HostingRecord hostingRecord,
int zygotePolicyFlags, boolean allowWhileBooting, boolean isolated, int isolatedUid,
boolean keepIfLarge, String abiOverride, String entryPoint, String[] entryPointArgs,
Runnable crashHandler) {
long startTime = SystemClock.uptimeMillis();
ProcessRecord app;
//isolated傳遞進來是false，
if (!isolated) {
//從mProcessNames緩存獲取，由于是首次創(chuàng)建，null
app = getProcessRecordLocked(processName, info.uid, keepIfLarge);
checkSlow(startTime, "startProcess: after getProcessRecord");
//判斷要啟動進程是否后臺運行，直接return null
if ((intentFlags & Intent.FLAG_FROM_BACKGROUND) != 0) {
if (mService.mAppErrors.isBadProcessLocked(info)) {
return null;
}
} else {
//重置進程的crash狀態(tài),使其處于正常狀態(tài)
mService.mAppErrors.resetProcessCrashTimeLocked(info);
if (mService.mAppErrors.isBadProcessLocked(info)) {
mService.mAppErrors.clearBadProcessLocked(info);
if (app != null) {
app.bad = false;
}
}
}
} else {
app = null;
}
ProcessRecord precedence = null;
if (app != null && app.pid > 0) {
if ((!knownToBeDead && !app.killed) || app.thread == null) {
app.addPackage(info.packageName, info.longVersionCode, mService.mProcessStats);
return app;
}
ProcessList.killProcessGroup(app.uid, app.pid);
precedence = app;
app = null;
}
if (app == null) {
// 分析一、創(chuàng)建新的應用進程描述ProcessRocrd
//內(nèi)部會將自己添加到mProcessNames中
app = newProcessRecordLocked(info, processName, isolated, isolatedUid, hostingRecord);
if (app == null) {
return null;
}
//此時三者都是null
app.crashHandler = crashHandler;
app.isolatedEntryPoint = entryPoint;
app.isolatedEntryPointArgs = entryPointArgs;
if (precedence != null) {
app.mPrecedence = precedence;
precedence.mSuccessor = app;
}
} else {
app.addPackage(info.packageName, info.longVersionCode, mService.mProcessStats);
}
// If the system is not ready yet, then hold off on starting this
// process until it is.
if (!mService.mProcessesReady
&& !mService.isAllowedWhileBooting(info)
&& !allowWhileBooting) {
if (!mService.mProcessesOnHold.contains(app)) {
mService.mProcessesOnHold.add(app);
}
if (DEBUG_PROCESSES) Slog.v(TAG_PROCESSES,
"System not ready, putting on hold: " + app);
checkSlow(startTime, "startProcess: returning with proc on hold");
return app;
}
分析二：
final boolean success =
startProcessLocked(app, hostingRecord, zygotePolicyFlags, abiOverride);
checkSlow(startTime, "startProcess: done starting proc!");
return success ? app : null;
}
6、ProcessList.startProcessLocked重載
再次調(diào)用另外一個重載函數(shù)。
final boolean startProcessLocked(ProcessRecord app, HostingRecord hostingRecord,
int zygotePolicyFlags, String abiOverride) {
return startProcessLocked(app, hostingRecord, zygotePolicyFlags,
false /* disableHiddenApiChecks */, false /* disableTestApiChecks */,
false /* mountExtStorageFull */, abiOverride);
}
重載函數(shù),這個重載函數(shù)處理邏輯很長，主要給前面創(chuàng)建的ProcessRecord類型的app設置各種屬性。例如外部存儲掛載模式，應用進程運行模式，abi架構等等，其中包括最重要一點就是分析一，確定要啟動進程的的類名：android.app.ActivityThread。分析二，繼續(xù)調(diào)用重載函數(shù)。
boolean startProcessLocked(ProcessRecord app, HostingRecord hostingRecord,
int zygotePolicyFlags, boolean disableHiddenApiChecks, boolean disableTestApiChecks,
boolean mountExtStorageFull, String abiOverride) {
...
app.gids = gids;
app.setRequiredAbi(requiredAbi);
app.instructionSet = instructionSet;
final String seInfo = app.info.seInfo
+ (TextUtils.isEmpty(app.info.seInfoUser) ? "" : app.info.seInfoUser);
//分析一：確定要啟動應用程序的類名
final String entryPoint = "android.app.ActivityThread";
//分析二：調(diào)用另外一個重載函數(shù)
return startProcessLocked(hostingRecord, entryPoint, app, uid, gids,
runtimeFlags, zygotePolicyFlags, mountExternal, seInfo, requiredAbi,
instructionSet, invokeWith, startTime);
} catch (RuntimeException e) {
...
}
}
重載函數(shù)：也是設置一些屬性，然后調(diào)用startProcess函數(shù)。
boolean startProcessLocked(HostingRecord hostingRecord, String entryPoint, ProcessRecord app,
int uid, int[] gids, int runtimeFlags, int zygotePolicyFlags, int mountExternal,
String seInfo, String requiredAbi, String instructionSet, String invokeWith,
long startTime) {
...
final Process.ProcessStartResult startResult = startProcess(hostingRecord,
entryPoint, app,
uid, gids, runtimeFlags, zygotePolicyFlags, mountExternal, seInfo,
requiredAbi, instructionSet, invokeWith, startTime);
handleProcessStartedLocked(app, startResult.pid, startResult.usingWrapper,
startSeq, false);
...
}
}
7、ProcessList.startProcess
ProcessList類的startProcess函數(shù)會根據(jù)hostingRecord屬性mHostingZygote判斷走不同的創(chuàng)建分支，前面創(chuàng)建使用默認值，所以走了else分支。通過 Process.start函數(shù)創(chuàng)建新的應用進程。
Process.start的一路調(diào)用:
Process.start=>ZygoteProcess.start=>ZygoteState.start=>ZygoteState.startViaZygote
8、ZygoteState.startViaZygote
startViaZygote函數(shù)，主要是將傳遞進來的參數(shù)拼接成成字符串和收集起來。其中processClass是
private Process.ProcessStartResult startViaZygote(...)
throws ZygoteStartFailedEx {
//根據(jù)傳遞進來的參數(shù)，拼接成字符串并收集到ArrayList<String>類型argsForZygote
//將作為新應用程序的主函數(shù)的參數(shù)
return zygoteSendArgsAndGetResult(openZygoteSocketIfNeeded(abi),
zygotePolicyFlags,
argsForZygote);
}
9、ZygoteState.openZygoteSocketIfNeeded
zygoteSendArgsAndGetResult的第一個參數(shù)，調(diào)用了openZygoteSocketIfNeeded函數(shù)。嘗試建立與Socket的連接（如果之前未建立的話）。我們知道Zygote進程在創(chuàng)建的過程，會調(diào)用runSelectLoop函數(shù)，創(chuàng)建Server端的Socket,一直等待來自AMS的Client端的Socket創(chuàng)建進程請求。
private ZygoteState openZygoteSocketIfNeeded(String abi) throws ZygoteStartFailedEx {
try {
//建立和Zygote的Socket連接
attemptConnectionToPrimaryZygote();
//匹配abi的架構。在Zygote的創(chuàng)建對應四種模式:32,32_64和64，64_32
//32,64
if (primaryZygoteState.matches(abi)) {
return primaryZygoteState;
}
//主要架構模式不配，匹配第二種 32_64,64_32
if (mZygoteSecondarySocketAddress != null) {
// The primary zygote didn't match. Try the secondary.
attemptConnectionToSecondaryZygote();
if (secondaryZygoteState.matches(abi)) {
return secondaryZygoteState;
}
}
} catch (IOException ioe) {
throw new ZygoteStartFailedEx("Error connecting to zygote", ioe);
}
throw new ZygoteStartFailedEx("Unsupported zygote ABI: " + abi);
}
attemptConnectionToPrimaryZygote函數(shù)主要通過底層的LocalSocket創(chuàng)建與Zygote進程的Socket連接，并獲得輸入流zygoteInputStream和輸出流zygoteOutputWriter。
private void attemptConnectionToPrimaryZygote() throws IOException {
if (primaryZygoteState == null || primaryZygoteState.isClosed()) {
primaryZygoteState =
ZygoteState.connect(mZygoteSocketAddress, mUsapPoolSocketAddress);
maybeSetApiBlacklistExemptions(primaryZygoteState, false);
maybeSetHiddenApiAccessLogSampleRate(primaryZygoteState);
}
}
和Zygote進程的Server端Socket建立連接后，就是開始往Socket寫數(shù)據(jù)了。
10、attemptZygoteSendArgsAndGetResult
回到第8步調(diào)用了zygoteSendArgsAndGetResult函數(shù)，又調(diào)用了attemptZygoteSendArgsAndGetResult函數(shù)。
zygoteSendArgsAndGetResult=>attemptZygoteSendArgsAndGetResult
11、attemptZygoteSendArgsAndGetResult
到這里，通過Socket的方式向Zygote進程寫進前面拼接好的參數(shù)，Zygote在Server端的Socket接收到數(shù)據(jù)之后，會執(zhí)行創(chuàng)建動作。在返回的result.pid>=0表示創(chuàng)建成功，并運行在新的進程。
private Process.ProcessStartResult attemptZygoteSendArgsAndGetResult(
ZygoteState zygoteState, String msgStr) throws ZygoteStartFailedEx {
try {
final BufferedWriter zygoteWriter = zygoteState.mZygoteOutputWriter;
final DataInputStream zygoteInputStream = zygoteState.mZygoteInputStream;
zygoteWriter.write(msgStr);
zygoteWriter.flush();
Process.ProcessStartResult result = new Process.ProcessStartResult();
result.pid = zygoteInputStream.readInt();
result.usingWrapper = zygoteInputStream.readBoolean();
if (result.pid < 0) {
throw new ZygoteStartFailedEx("fork() failed");
}
return result;
} catch (IOException ex) {
zygoteState.close();
Log.e(LOG_TAG, "IO Exception while communicating with Zygote - "
+ ex.toString());
throw new ZygoteStartFailedEx(ex);
}
}
12、Zygote.main
在Zygote的啟動流程過程，調(diào)用了ZygoteInit的main函數(shù)，因為Zygote是通過fork自身來創(chuàng)建其他進程，所以需要根據(jù)傳遞進來的參數(shù)，進行判斷是啟動什么類型的進程，例如自身isPrimaryZygote=true，或者SystemServer進程。然后通過ZygoteServer.runSelectLoop函數(shù)，等待其他進程請求創(chuàng)建新的進程。
public static void main(String argv[]) {
ZygoteServer zygoteServer = null;
Runnable caller;
try {
...
boolean startSystemServer = false;
String zygoteSocketName = "zygote";
String abiList = null;
boolean enableLazyPreload = false;
for (int i = 1; i < argv.length; i++) {
if ("start-system-server".equals(argv[i])) {
startSystemServer = true; //判斷是否SystemServer進程
} else if ("--enable-lazy-preload".equals(argv[i])) {
enableLazyPreload = true;
} else if (argv[i].startsWith(ABI_LIST_ARG)) {
abiList = argv[i].substring(ABI_LIST_ARG.length());
} else if (argv[i].startsWith(SOCKET_NAME_ARG)) {
//SCOKET_NAME_ARG="--socket-name=",根據(jù)參數(shù)得到SocketName
zygoteSocketName = argv[i].substring(SOCKET_NAME_ARG.length());
} else {
throw new RuntimeException("Unknown command line argument: " + argv[i]);
}
}
//PRIMARY_SOCKET_NAME=zygote
final boolean isPrimaryZygote = zygoteSocketName.equals(Zygote.PRIMARY_SOCKET_NAME);
gcAndFinalize();
Zygote.initNativeState(isPrimaryZygote);
ZygoteHooks.stopZygoteNoThreadCreation();
zygoteServer = new ZygoteServer(isPrimaryZygote);
if (startSystemServer) {
//啟動SystemServer進程
Runnable r = forkSystemServer(abiList, zygoteSocketName, zygoteServer);
if (r != null) {
r.run();
return;
}
}
//循環(huán)等待AMS來請求創(chuàng)建新的進程
caller = zygoteServer.runSelectLoop(abiList);
} catch (Throwable ex) {
Log.e(TAG, "System zygote died with exception", ex);
throw ex;
} finally {
if (zygoteServer != null) {
zygoteServer.closeServerSocket();
}
}
//調(diào)用新的進程主函數(shù)
if (caller != null) {
caller.run();
}
}
13、ZygoteServer.runSelectLoo
這里只關注ZygoteServer.runSelectLoop函數(shù)，接受Socket客戶端數(shù)據(jù)。
/**
* Runs the zygote process's select loop. Accepts new connections as
* they happen, and reads commands from connections one spawn-request's
* worth at a time.
*/
Runnable runSelectLoop(String abiList) {
while (true) {
...
ZygoteConnection connection = peers.get(pollIndex);
final Runnable command = connection.processOneCommand(this);
...
if (mIsForkChild) {
return command;
}
....
}
}
14、ZygoteConnection.processOneCommand
runSelctLoop主要是從循環(huán)中檢測是否有連接建立，建立之后執(zhí)行ZygoteConnection的processOneCommand函數(shù)，并返回一個Runable類型的command對象。
Runnable processOneCommand(ZygoteServer zygoteServer) {
...
args = Zygote.readArgumentList(mSocketReader);
//根據(jù)參數(shù)內(nèi)容，作其他類型的處理
...
//創(chuàng)建進程,調(diào)用底層nativeForkAndSpecialize方法，通過fork當前進程來創(chuàng)建一個子線程。
pid = Zygote.forkAndSpecialize(parsedArgs.mUid, parsedArgs.mGid, parsedArgs.mGids,
parsedArgs.mRuntimeFlags, rlimits, parsedArgs.mMountExternal, parsedArgs.mSeInfo,
parsedArgs.mNiceName, fdsToClose, fdsToIgnore, parsedArgs.mStartChildZygote,
parsedArgs.mInstructionSet, parsedArgs.mAppDataDir, parsedArgs.mIsTopApp,
parsedArgs.mPkgDataInfoList, parsedArgs.mWhitelistedDataInfoList,
parsedArgs.mBindMountAppDataDirs, parsedArgs.mBindMountAppStorageDirs);
...
if (pid == 0) {
//設置mIsForkChild=true
zygoteServer.setForkChild();
//關閉Socket連接
zygoteServer.closeServerSocket();
IoUtils.closeQuietly(serverPipeFd);
serverPipeFd = null;
//執(zhí)行子進程內(nèi)容
return handleChildProc(parsedArgs, childPipeFd, parsedArgs.mStartChildZygote);
}
...
}
15、handleChildProc
handleChildProc函數(shù)。
private Runnable handleChildProc(ZygoteArguments parsedArgs,
FileDescriptor pipeFd, boolean isZygote) {
...
if (!isZygote) {
return ZygoteInit.zygoteInit(parsedArgs.mTargetSdkVersion,
parsedArgs.mDisabledCompatChanges,
parsedArgs.mRemainingArgs, null /* classLoader */);
} else {
return ZygoteInit.childZygoteInit(parsedArgs.mTargetSdkVersion,
parsedArgs.mRemainingArgs, null /* classLoader */);
}
}
16、 ZygoteInit.zygoteInit
public static final Runnable zygoteInit(int targetSdkVersion, long[] disabledCompatChanges,
String[] argv, ClassLoader classLoader) {
RuntimeInit.commonInit();
ZygoteInit.nativeZygoteInit();//為新進程創(chuàng)建Binder線程池
return RuntimeInit.applicationInit(targetSdkVersion, disabledCompatChanges, argv,
classLoader);
}
以前還以為每個進程共用一個Binder線程池，現(xiàn)在知道每個進程都有自己的Binder線程池進行IPC。
17、RuntimeInit.applicationInit
protected static Runnable applicationInit(int targetSdkVersion, long[] disabledCompatChanges,
String[] argv, ClassLoader classLoader) {
final Arguments args = new Arguments(argv);
return findStaticMain(args.startClass, args.startArgs, classLoader);
}
這里的args.startClass就是Socket客戶端傳遞下來的android.app.ActivityThread。
18、RuntimeInit.findStaticMain
RuntimeInit.findStaticMain函數(shù)主要通過反射創(chuàng)建ActivityThread類的實例，并反射主函數(shù)main，然后封裝到MethodAndArgsCaller實例中返回。
protected static Runnable findStaticMain(String className, String[] argv,
ClassLoader classLoader) {
...
Class<?> cl = Class.forName(className, true, classLoader);
Method m = cl.getMethod("main", new Class[] { String[].class });
...
return new MethodAndArgsCaller(m, argv);
}
MethodAndArgsCaller類繼承自Runable,并在其run函數(shù)，調(diào)用主函數(shù)方法。
static class MethodAndArgsCaller implements Runnable {
/** method to call */
private final Method mMethod;
/** argument array */
private final String[] mArgs;
public MethodAndArgsCaller(Method method, String[] args) {
mMethod = method;
mArgs = args;
}
public void run() {
...
mMethod.invoke(null, new Object[] { mArgs });
...
}
}
隨著findStaticMain函數(shù)方法棧一路返回到runSelectLoop函數(shù)，因為mIsForkChild是true，所以MethodAndArgsCaller對象返回到ZygoteInit的main函數(shù)，并賦值給caller變量。main函數(shù)最后調(diào)用caller的run函數(shù)。即執(zhí)行了ActivityThread的主函數(shù)main。
本來自己還有個疑惑，fork子進程之后，并caller的run函數(shù)，已經(jīng)退出了Zygote進程的runSelectLoop循環(huán)等待。怎么繼續(xù)去接收AMS新的請求。原來如此，fork子進程后，后續(xù)的代碼都運行在了子進程，這里return其實是子進程了。
一個進程調(diào)用fork（）函數(shù)后，系統(tǒng)先給新的進程分配資源，例如存儲數(shù)據(jù)和代碼的空間。然后把原來的進程的所有值都復制到新的新進程中，只有少數(shù)值與原來的進程的值不同。相當于克隆了一個自己。
19、進程ActivityThread.main。
public static void main(String[] args) {
Looper.prepareMainLooper();
ActivityThread thread = new ActivityThread();
thread.attach(false, startSeq);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
Looper.loop();
}
ActivityThread的主函數(shù)，創(chuàng)建了ActivityThread進程，并啟動了消息循環(huán)隊列，代表著當前進程的主線程已啟動。
知識點
- fork函數(shù)。
- 通過Socket創(chuàng)建新的進程。
- Binder機制和應用程序創(chuàng)建的時機。
- ActivityThread的進程的主線程。
疑問點
- 通過Zygote進程fork而來的子進程都會獲得Zygote創(chuàng)建的Java虛擬機，也就是每個應用進程都有自己的Java虛擬機。
- 每個應用進程都有屬于自己的Binder線程池和消息循環(huán)機制。
- 之所以fork Zygote進程而不是init進程，是避免重復初始化環(huán)境資源的加載和虛擬機的創(chuàng)建。
- 進程的創(chuàng)建之所選擇Socket機制進行，因為Binder機制會導致死鎖，怕父進程binder線程有鎖，然后子進程的主線程一直在等其子線程(從父進程拷貝過來的子進程)的資源，但是其實父進程的子進程并沒有被拷貝過來，造成死鎖，所以fork不允許存在多線程。
以上就是Android 應用程序的啟動流程示例詳解的詳細內(nèi)容，更多關于Android 程序啟動流程的資料請關注腳本之家其它相關文章！
相關文章
Android SpannableString設置超鏈接、顏色、字體等屬性
這篇文章主要介紹了Android SpannableString設置超鏈接、顏色、字體等屬性的相關資料,需要的朋友可以參考下2017-01-01
Android音頻開發(fā)之音頻采集的實現(xiàn)示例
本篇文章主要介紹了Android音頻開發(fā)之音頻采集的實現(xiàn)示例，小編覺得挺不錯的，現(xiàn)在分享給大家，也給大家做個參考。一起跟隨小編過來看看吧2018-04-04
Android中閃屏實現(xiàn)方法小結(普通閃屏、倒計時閃屏、倒計時+動畫閃屏)
這篇文章主要介紹了Android中閃屏實現(xiàn)方法小結(普通閃屏、倒計時閃屏、倒計時+動畫閃屏),非常不錯，代碼簡單易懂，需要的朋友可以參考下2017-01-01
這篇文章主要為大家詳細介紹了Android實現(xiàn)圖片上傳蒙層進度條，文中示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下2022-09-09
這篇文章主要介紹了Kotlin中的對象表達式和對象聲明的具體使用，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧2019-11-11
Android實現(xiàn)網(wǎng)易新聞客戶端側滑菜單（2）
這篇文章主要為大家詳細介紹了Android實現(xiàn)網(wǎng)易新聞客戶端側滑菜單第二篇,具有一定的參考價值，感興趣的小伙伴們可以參考一下2016-11-11
這篇文章主要介紹了Android微信SDK實現(xiàn)分享的相關資料，具有一定的參考價值，感興趣的小伙伴們可以參考一下2016-12-12
這篇文章主要介紹了Android 自定義EditText輸入框帶清空按鈕的相關資料,需要的朋友可以參考下2017-05-05
這篇文章主要為大家詳細介紹了Android調(diào)用攝像頭拍照的開發(fā)教程，具有一定的參考價值，感興趣的小伙伴們可以參考一下2018-04-04
Android Java調(diào)用自己C++類庫的實例講解
今天小編就為大家分享一篇關于Android Java調(diào)用自己C++類庫的實例講解，小編覺得內(nèi)容挺不錯的，現(xiàn)在分享給大家，具有很好的參考價值，需要的朋友一起跟隨小編來看看吧2019-02-02