ANR原理和分析

已于 2024-09-05 18:43:41 修改
阅读量152 收藏
点赞数 4
分类专栏： 安卓跨层知识 文章标签： android
于 2024-07-24 15:04:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xuanfengwuxiang/article/details/140663596
版权

背景

  ANR分析需要结合各个层面大量的数据，诸如堆栈信息、Android log等。可能是app出了问题，也可能是framwork出了问题，甚至是内核出了问题。那么理解anr的机制，才能分析好具体的ANR问题。

  ANR就是应用无响应，超过一定时间，由system server进程弹窗提示。
  ANR分类：1.Service(前台超时20s) 2. Broadcast(前台超时10s) 3. ContentProvider(前台超时10s) 4.InputDispatcing(超时5s)
  ANR过程：埋炸弹—>拆炸弹/引爆炸弹

ANR原理

  Sevice ANR原理:

    Service启动过程中：1、AMS收到启动请求，由ActiveServices埋炸弹。2、AMS资源处理完成通知app，app在service的onCreate()之后，请求AMS拆除炸弹，由ActiveServices拆除炸弹。3、如果启动超时，将由ActiveServices引爆炸弹
    1、埋炸弹
  /frameworks/base/services/core/java/com/android/server/am/ActiveServices.java

final ActivityManagerService mAm;
//启动流程，经过层层函数到这儿
private void realStartServiceLocked(ServiceRecord r, ProcessRecord app,IApplicationThread thread, int pid, UidRecord uidRecord, boolean execInFg,boolean enqueueOomAdj) throws RemoteException {
	bumpServiceExecutingLocked(r, execInFg, "create",OOM_ADJ_REASON_NONE /* use "none" to avoid extra oom adj */);
	//通知app走onCreate()
    thread.scheduleCreateService(r, r.serviceInfo,null,app.mState.getReportedProcState());
}
private boolean bumpServiceExecutingLocked(ServiceRecord r, boolean fg, String why, @OomAdjReason int oomAdjReason) {
	 scheduleServiceTimeoutLocked(r.app);
}
void scheduleServiceTimeoutLocked(ProcessRecord proc) {          
     //炸弹开始倒计时
     mAm.mHandler.sendMessageDelayed(msg, proc.mServices.shouldExecServicesFg()? mAm.mConstants.SERVICE_TIMEOUT :mAm.mConstants.SERVICE_BACKGROUND_TIMEOUT);
}

    2、拆炸弹
    /frameworks/base/core/java/android/app/ActivityThread.java

//app接到通知
private class ApplicationThread extends IApplicationThread.Stub {
	 public final void scheduleCreateService(IBinder token,ServiceInfo info, CompatibilityInfo compatInfo, int processState) {
	 	sendMessage(H.CREATE_SERVICE, s);
     }
}
class H extends Handler {//主线程
	public void handleMessage(Message msg) {
		switch (msg.what) {
			case CREATE_SERVICE:
				handleCreateService((CreateServiceData)msg.obj);
				break;
		}
	}
}
private void handleCreateService(CreateServiceData data) {
	service.onCreate();
	ActivityManager.getService().serviceDoneExecuting(data.token, SERVICE_DONE_EXECUTING_ANON, 0, 0);
}

  /frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java

final ActiveServices mServices;
public void serviceDoneExecuting(IBinder token, int type, int startId, int res) {
    mServices.serviceDoneExecutingLocked((ServiceRecord) token, type, startId, res, false);
}

  /frameworks/base/services/core/java/com/android/server/am/ActiveServices.java

private void serviceDoneExecutingLocked(ServiceRecord r, boolean inDestroying,boolean finishing, boolean enqueueOomAdj, @OomAdjReason int oomAdjReason) {
	//拆除炸弹
	mAm.mHandler.removeMessages(ActivityManagerService.SERVICE_TIMEOUT_MSG, r.app);
}

    3、引爆炸弹
    /frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java

final MainHandler mHandler;
final ActiveServices mServices;
final class MainHandler extends Handler {
		public void handleMessage(Message msg) {
			switch (msg.what) {
				 case SERVICE_TIMEOUT_MSG: {
                  		mServices.serviceTimeout((ProcessRecord) msg.obj);
              			} break;
              	 case SERVICE_FOREGROUND_TIMEOUT_MSG: {
                  		mServices.serviceForegroundTimeout((ServiceRecord) msg.obj);
              			} break;
			}
		}
}

  /frameworks/base/services/core/java/com/android/server/am/ActiveServices.java

void serviceTimeout(ProcessRecord proc) {
	mAm.mAnrHelper.appNotResponding(proc, timeoutRecord);
}

  Broadcast ANR原理:

    发送广播的过程：1、AMS收到app请求，由BroadcastQueueImpl埋炸弹。2、AMS完成资源处理，通知app回调receiver的onReceive(),之后app请求AMS拆除炸弹 3、如果超时，由BroadcastQueueImpl引爆炸弹
    注意：串行广播才有ANR，并行广播没有。广播ANR细分为2种：1、broadcast的ANR，主要计算receiver数量的总时长。 2、BroadcastReceiver的ANR，主要计算单个receiver的时长。
    1、埋炸弹
    /frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java

//app请求到这儿
public final int broadcastIntentWithFeature(IApplicationThread caller, .....) {
 	return broadcastIntentLocked(callerApp,...........);
}
final int broadcastIntentLocked(ProcessRecord callerApp,......){
	final int res = broadcastIntentLockedTraced(callerApp,........);
}
final int broadcastIntentLockedTraced(ProcessRecord callerApp,....){
 	BroadcastQueue queue = broadcastQueueForIntent(intent);
	queue.enqueueBroadcastLocked(r);
}

    /frameworks/base/services/core/java/com/android/server/am/BroadcastQueueImpl.java

final BroadcastHandler mHandler;
boolean mBroadcastsScheduled = false;//标志-有广播正在处理
public void enqueueBroadcastLocked(BroadcastRecord r) {
	enqueueOrderedBroadcastLocked(r);
	scheduleBroadcastsLocked();
}
public void scheduleBroadcastsLocked() {
	if (mBroadcastsScheduled) {//当前广播正在处理，拒绝下一个广播
         return;
    }
	mHandler.sendMessage(mHandler.obtainMessage(BROADCAST_INTENT_MSG, this));
	mBroadcastsScheduled = true;
}
private final class BroadcastHandler extends Handler {
	public void handleMessage(Message msg) {
		switch (msg.what) {
                  case BROADCAST_INTENT_MSG: {
                      processNextBroadcast(true);
                     } break;
                  case BROADCAST_TIMEOUT_MSG: {
                      broadcastTimeoutLocked(true);
                  } break;
         }
	}
}
private void processNextBroadcast(boolean fromMsg) {
      processNextBroadcastLocked(fromMsg, false);
}
public void processNextBroadcastLocked(boolean fromMsg, boolean skipOomAdj) {
	 BroadcastRecord r;
	 if (fromMsg) {
	     mBroadcastsScheduled = false;
     }
     ................................//并行广播分发省略，不存在ANR 
     //处理串行广播
     do {
		r = mDispatcher.getNextBroadcastLocked(now);
		//广播分发，总时间超时，也会ANR。
     	if (mService.mProcessesReady && !r.timeoutExempt && r.dispatchTime > 0) {
     		if ((numReceivers > 0) && (now > r.dispatchTime + (2 * mConstants.TIMEOUT * numReceivers))) {
     		 	broadcastTimeoutLocked(false); // forcibly finish this broadcast,此处也会弹ANR，省略
     		}
     	} 
	 } while (r == null);
	 //准备分发给receiver了
	 int recIdx = r.nextReceiver++;
	 r.receiverTime = SystemClock.uptimeMillis();//更新 每个receiver分发 开始时间，用于判断单个receiver是否超时。
	 if (recIdx == 0) {//记录 第一个receiver 分发时间，控制分发总时间的ANR。埋了一个“总时长炸弹”
	 	r.dispatchTime = r.receiverTime;
	 }
	 //埋了“单个receiver炸弹”
	 setBroadcastTimeoutLocked(timeoutTime);
	 //分发receiver 
	 deliverToRegisteredReceiverLocked(r, filter, r.ordered, recIdx);
}
//埋炸弹
final void setBroadcastTimeoutLocked(long timeoutTime) {
	if (! mPendingBroadcastTimeoutMessage) {//上一个receiver的炸弹，倒计时没结束，当前receiver暂不埋炸弹。
	   Message msg = mHandler.obtainMessage(BROADCAST_TIMEOUT_MSG, this);
       mHandler.sendMessageAtTime(msg, timeoutTime);
       mPendingBroadcastTimeoutMessage = true;
	}
}
private void deliverToRegisteredReceiverLocked(BroadcastRecord r,BroadcastFilter filter, boolean ordered, int index) {
		performReceiveLocked(r,........);
}
//通知app走reciever的onRecieve()
public void performReceiveLocked(BroadcastRecord r,){
	final IApplicationThread thread = app.getThread();
	thread.scheduleRegisteredReceiver(......);
}

    2、拆炸弹
    /frameworks/base/core/java/android/app/ActivityThread.java

private class ApplicationThread extends IApplicationThread.Stub {
	public void scheduleRegisteredReceiver(IIntentReceiver receiver, ....){
		receiver.performReceive(intent, resultCode, dataStr, extras, ordered, sticky, sendingUser);
	}
}

    /frameworks/base/core/java/android/app/LoadedApk.java

static final class ReceiverDispatcher {
	final static class InnerReceiver extends IIntentReceiver.Stub {
		public void performReceive(){
			final LoadedApk.ReceiverDispatcher rd;
			rd.performReceive(intent, resultCode, data, extras,ordered, sticky, assumeDelivered, sendingUser,sendingUid, sendingPackage);
		}
	}
	public void performReceive(Intent intent, int resultCode, String data,Bundle extras, boolean ordered, boolean sticky, boolean assumeDelivered,int sendingUser, int sendingUid, String sendingPackage) {
		final Args args = new Args(intent, resultCode, data, extras, ordered,sticky, assumeDelivered, sendingUser, sendingUid, sendingPackage);
		if (intent == null || !mActivityThread.post(args.getRunnable())) {//调用receiver的onReceive()
			IActivityManager mgr = ActivityManager.getService();
			args.sendFinished(mgr);
		}
	}
	final class Args extends BroadcastReceiver.PendingResult {
		public final Runnable getRunnable() {
			final BroadcastReceiver receiver = mReceiver;
			receiver.onReceive(mContext, intent);
		}
	}
}

    /frameworks/base/core/java/android/content/BroadcastReceiver.java

public static class PendingResult {
	public void sendFinished(IActivityManager am) {
		am.finishReceiver(mToken, mResultCode, mResultData, mResultExtras,mAbortBroadcast, mFlags);
	}
}

    /frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java

public void finishReceiver(IBinder caller, int resultCode, String resultData,Bundle resultExtras, boolean resultAbort, int flags) {
	queue.finishReceiverLocked(callerApp, resultCode,resultData, resultExtras, resultAbort, true);
}

/frameworks/base/services/core/java/com/android/server/am/BroadcastQueueImpl.java

public boolean finishReceiverLocked(ProcessRecord app, int resultCode,String resultData, Bundle resultExtras, boolean resultAbort, boolean waitForServices) {
	return finishReceiverLocked(r, resultCode, resultData, resultExtras, resultAbort, waitForServices);
}
public boolean finishReceiverLocked(BroadcastRecord r, int resultCode,String resultData, Bundle resultExtras, boolean resultAbort, boolean waitForServices) {
	processNextBroadcastLocked(/* fromMsg= */ false, /* skipOomAdj= */ true);
}
public void processNextBroadcastLocked(boolean fromMsg, boolean skipOomAdj) {
	do {//处理串行广播
		//分发最后一个receiver时，拆掉 总时长炸弹。
		if (r.receivers == null || r.nextReceiver >= numReceivers || r.resultAbort || forceReceive) {
			cancelBroadcastTimeoutLocked();
		}
	 } while (r == null);
}
//这里拆除单个receiver炸弹。这里的代码真的太骚了！！！我找了好久！！！
final void broadcastTimeoutLocked(boolean fromMsg) {
	if (fromMsg) {//从Handler倒计时满了过来的，才设置下面的标志位，表示允许埋 单个receiver炸弹
    	mPendingBroadcastTimeoutMessage = false;
    }
    if (fromMsg) {
    	long timeoutTime = r.receiverTime + mConstants.TIMEOUT;
    	if (timeoutTime > now) {//下一个receiver开始分发了，r.receiverTime被更新，并且下一个receiver还没超时。那本次也没超时
    		setBroadcastTimeoutLocked(timeoutTime);//这里才开始埋下一个receiver的炸弹
    		return;//本次分发没超时，直接return了。惊不惊喜意不意外！
    	}
    }
}

    3、引爆炸弹
/frameworks/base/services/core/java/com/android/server/am/BroadcastQueueImpl.java

final void broadcastTimeoutLocked(boolean fromMsg) {
	 //前面的代码判断超时，会走到这一步
	 mService.appNotResponding(app, timeoutRecord);
}

  ContentProvider ANR原理:

    首先ContentProvider的启动过程，包含在app的启动过程中。AMS亲自埋炸弹。注意不会弹ANR弹窗，会直接杀死app。
    1、埋炸弹
    /frameworks/base/core/java/android/app/ActivityThread.java

public static void main(String[] args) {
	ActivityThread thread = new ActivityThread();
    thread.attach(false, startSeq);
}
private void attach(boolean system, long startSeq) {
	final IActivityManager mgr = ActivityManager.getService();
	mgr.attachApplication(mAppThread, startSeq);
}

    /frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java

public final void attachApplication(IApplicationThread thread, long startSeq) {
	attachApplicationLocked(thread, callingPid, callingUid, startSeq);
}
private boolean attachApplicationLocked(@NonNull IApplicationThread thread, int pid, int callingUid, long startSeq) {
	List<ProviderInfo> providers = normalMode ? mCpHelper.generateApplicationProvidersLocked(app) : null;
	//埋炸弹
    if (providers != null && mCpHelper.checkAppInLaunchingProvidersLocked(app)) {
            Message msg = mHandler.obtainMessage(CONTENT_PROVIDER_PUBLISH_TIMEOUT_MSG);
            msg.obj = app;
            mHandler.sendMessageDelayed(msg, ContentResolver.CONTENT_PROVIDER_PUBLISH_TIMEOUT_MILLIS);
    }
    //通知app处理ContentProvider流程
	thread.bindApplication(processName, appInfo, providerList,........);
}

    2、拆炸弹

    /frameworks/base/core/java/android/app/ActivityThread.java

private class ApplicationThread extends IApplicationThread.Stub {
	public final void bindApplication(String processName, ApplicationInfo appInfo, ProviderInfoList providerList, ...) {
		sendMessage(H.BIND_APPLICATION, data);
    }
}
class H extends Handler {
	public void handleMessage(Message msg) {
		switch (msg.what) {
			case BIND_APPLICATION:
			handleBindApplication(data);
			break;
		}
	}
}
private void handleBindApplication(AppBindData data) {
	installContentProviders(app, data.providers);
	mInstrumentation.callApplicationOnCreate(app);
}
private void installContentProviders(Context context, List<ProviderInfo> providers) {
	//创建ContentProvider
	ContentProviderHolder cph = installProvider(context, null, cpi,false /*noisy*/, true /*noReleaseNeeded*/, true /*stable*/);
	results.add(cph);
	ActivityManager.getService().publishContentProviders(getApplicationThread(), results);
}

    /frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java

public final void publishContentProviders(IApplicationThread caller,List<ContentProviderHolder> providers) {
	 mCpHelper.publishContentProviders(caller, providers);
}

    /frameworks/base/services/core/java/com/android/server/am/ContentProviderHelper.java

void publishContentProviders(IApplicationThread caller, List<ContentProviderHolder> providers) {
	//拆除炸弹
	mService.mHandler.removeMessages( ActivityManagerService.CONTENT_PROVIDER_PUBLISH_TIMEOUT_MSG, r);
}

    3、引爆炸弹
    /frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java

final class MainHandler extends Handler {
	public void handleMessage(Message msg) {
		switch (msg.what) {
			case CONTENT_PROVIDER_PUBLISH_TIMEOUT_MSG: {
                mCpHelper.processContentProviderPublishTimedOutLocked(app);
            } break;
		}
	}
}

    /frameworks/base/services/core/java/com/android/server/am/ContentProviderHelper.java

void processContentProviderPublishTimedOutLocked(ProcessRecord app) {
	cleanupAppInLaunchingProvidersLocked(app, true);
	mService.mProcessList.removeProcessLocked(app,.....);
}

    /frameworks/base/services/core/java/com/android/server/am/ProcessList.java

boolean removeProcessLocked(ProcessRecord app,.....) {
	 //直接干掉app
	 app.killLocked(reason, reasonCode, subReason, true, async);
}

  InputDispatching ANR原理:

    EventHub负责监听/dev/input产生的input事件，InputReader负责从EventHub读取事件，并将事件分发给InputDispatcher，InputDispatcher分发给当前获取到焦点的Window。ANR在InputDispatcher的流程里面。
    埋炸弹
    /frameworks/native/services/inputflinger/dispatcher/InputDispatcher.cpp

// 超时时间
const std::chrono::duration DEFAULT_INPUT_DISPATCHING_TIMEOUT = std::chrono::milliseconds( android::os::IInputConstants::UNMULTIPLIED_DEFAULT_DISPATCHING_TIMEOUT_MILLIS *HwTimeoutMultiplier());

status_t InputDispatcher::start() {
      mThread = std::make_unique<InputThread>("InputDispatcher", [this]() { dispatchOnce(); }, [this]() { mLooper->wake(); });
}
void InputDispatcher::dispatchOnce() {
	dispatchOnceInnerLocked(&nextWakeupTime);
	//检查ANR
	const nsecs_t nextAnrCheck = processAnrsLocked();
}
void InputDispatcher::dispatchOnceInnerLocked(nsecs_t* nextWakeupTime) {
	//mInboundQueue取出一个Event
	mPendingEvent = mInboundQueue.front();
	switch (mPendingEvent->type) {
		case EventEntry::Type::KEY: {//按键
			done = dispatchKeyLocked(currentTime, keyEntry, &dropReason, nextWakeupTime);
			break;
		}
		case EventEntry::Type::MOTION: {//手势
			done = dispatchMotionLocked(currentTime, motionEntry, &dropReason, nextWakeupTime);
		}
	}
}
// 分发按键
bool InputDispatcher::dispatchKeyLocked(nsecs_t currentTime, std::shared_ptr<KeyEntry> entry, DropReason* dropReason, nsecs_t* nextWakeupTime) {
	// 找到focusedWindow，这里 会埋下 noFocusedWindow超时时间
	sp<WindowInfoHandle> focusedWindow =findFocusedWindowTargetLocked(currentTime, *entry, nextWakeupTime,injectionResult);
	dispatchEventLocked(currentTime, entry, inputTargets);
}
// 分发手势
bool InputDispatcher::dispatchMotionLocked(nsecs_t currentTime, std::shared_ptr<MotionEntry> entry,DropReason* dropReason, nsecs_t* nextWakeupTime) {
	if (isPointerEvent) {
	}else{// 找到focusedWindow，这里 会埋下 noFocusedWindow超时时间
		sp<WindowInfoHandle> focusedWindow = findFocusedWindowTargetLocked(currentTime, *entry, nextWakeupTime, injectionResult);
	}
	dispatchEventLocked(currentTime, entry, inputTargets);
}
sp<WindowInfoHandle> InputDispatcher::findFocusedWindowTargetLocked(){
	// 有focused的app，但没有focused的window
	if (focusedWindowHandle == nullptr && focusedApplicationHandle != nullptr) {
		if (!mNoFocusedWindowTimeoutTime.has_value()) {
			 std::chrono::nanoseconds timeout = focusedApplicationHandle->getDispatchingTimeout(DEFAULT_INPUT_DISPATCHING_TIMEOUT);
			 //埋炸弹--noFocusedWindow类型ANR
			 mNoFocusedWindowTimeoutTime = currentTime + timeout.count();
			 return nullptr;
		}
	}
	// 有focusedWindow取消ANR计时
	resetNoFocusedWindowTimeoutLocked();
}
// 不管是按键还是手势，都到分发事件函数
void InputDispatcher::dispatchEventLocked(nsecs_t currentTime,std::shared_ptr<EventEntry> eventEntry, const std::vector<InputTarget>& inputTargets) {
	for (const InputTarget& inputTarget : inputTargets) {
		prepareDispatchCycleLocked(currentTime, connection, eventEntry, inputTarget);
	}
}
void InputDispatcher::prepareDispatchCycleLocked(nsecs_t currentTime,const std::shared_ptr<Connection>& connection,std::shared_ptr<EventEntry> eventEntry,const InputTarget& inputTarget) {
	enqueueDispatchEntriesLocked(currentTime, connection, eventEntry, inputTarget);
}
void InputDispatcher::enqueueDispatchEntriesLocked(nsecs_t currentTime,const std::shared_ptr<Connection>& connection,std::shared_ptr<EventEntry> eventEntry,const InputTarget& inputTarget) {
	//将dispatchEntry放入connection->outboundQueue
	enqueueDispatchEntryLocked(connection, eventEntry, inputTarget, InputTarget::Flags::DISPATCH_AS_HOVER_EXIT);
	startDispatchCycleLocked(currentTime, connection);
}
void InputDispatcher::startDispatchCycleLocked(nsecs_t currentTime,const std::shared_ptr<Connection>& connection) {
	while (connection->status == Connection::Status::NORMAL && !connection->outboundQueue.empty()) {
		DispatchEntry* dispatchEntry = connection->outboundQueue.front();
		const std::chrono::nanoseconds timeout = getDispatchingTimeoutLocked(connection);
		//设置超时时间
		dispatchEntry->timeoutTime = currentTime + timeout.count();
		switch (eventEntry.type) {
			case EventEntry::Type::KEY: {//将按键事件分发给Java层
				status = connection->inputPublisher.publishKeyEvent(dispatchEntry->seq,...);
				break;
			}
			case EventEntry::Type::MOTION: {//将手势事件分发给Java层
				status = publishMotionEvent(*connection, *dispatchEntry);
				break;
			}
		}
		//为了表示正在分发中，event重新入队wait queue.
        connection->outboundQueue.erase(std::remove(connection->outboundQueue.begin(),connection->outboundQueue.end(),dispatchEntry));
        connection->waitQueue.push_back(dispatchEntry);
		//埋炸弹--分发超时ANR
		mAnrTracker.insert(dispatchEntry->timeoutTime, connection->inputChannel->getConnectionToken());
	}
}
std::chrono::nanoseconds InputDispatcher::getDispatchingTimeoutLocked(const std::shared_ptr<Connection>& connection) {
	return DEFAULT_INPUT_DISPATCHING_TIMEOUT;
}
status_t InputDispatcher::publishMotionEvent(Connection& connection,DispatchEntry& dispatchEntry) const {
	return connection.inputPublisher.publishMotionEvent(dispatchEntry.seq,...);
}

    /frameworks/native/libs/input/android/os/IInputConstants.aidl

	const int UNMULTIPLIED_DEFAULT_DISPATCHING_TIMEOUT_MILLIS = 5000; // 5 seconds

    拆炸弹

    引爆炸弹
    /frameworks/native/services/inputflinger/dispatcher/InputDispatcher.cpp

nsecs_t InputDispatcher::processAnrsLocked() {
	nsecs_t nextAnrCheck = LLONG_MAX; // 下一次检查anr的时间
	// 检查 是否在等待 聚焦窗口出现。如果超时 报ANR
	if (mNoFocusedWindowTimeoutTime.has_value() && mAwaitedFocusedApplication != nullptr) {
		if (currentTime >= *mNoFocusedWindowTimeoutTime) {
			//场景1：noFocusedWindow的ANR
			processNoFocusedWindowAnrLocked();
		}
	}
	// 检查分发类型 ANRs 是否超时
	nextAnrCheck = std::min(nextAnrCheck, mAnrTracker.firstTimeout());
	if (currentTime < nextAnrCheck) {
          return nextAnrCheck;        
    }
	// 分发 超时了
	std::shared_ptr<Connection> connection = getConnectionLocked(mAnrTracker.firstToken());
	//删除记录的超时 
	mAnrTracker.eraseToken(connection->inputChannel->getConnectionToken());
	// 场景2：分发超时ANR
	onAnrLocked(connection);
}
void InputDispatcher::processNoFocusedWindowAnrLocked() {
	// 没有焦点app 或 焦点app不是我们等的那个
	if (focusedApplication == nullptr || focusedApplication->getApplicationToken() != mAwaitedFocusedApplication->getApplicationToken()) {
		return;//直接返回，因为焦点app已经变更
	}
	// 再次检查焦点app,是否焦点window
	const sp<WindowInfoHandle>& focusedWindowHandle = getFocusedWindowHandleLocked(mAwaitedApplicationDisplayId);
	if (focusedWindowHandle != nullptr) {
          return; // 有focused window了. 无需触发ANR了.
    }
    onAnrLocked(mAwaitedFocusedApplication);
}
void InputDispatcher::onAnrLocked(const std::shared_ptr<Connection>& connection) {
	// 之前将正在分发的event放到了waitQueue，现在它空了，那就不弹ANR了
	if (connection->waitQueue.empty()) {
		return;
	}
	processConnectionUnresponsiveLocked(*connection, std::move(reason));
}
void InputDispatcher::processConnectionUnresponsiveLocked(const Connection& connection,std::string reason) {
	sendWindowUnresponsiveCommandLocked(connectionToken, pid, std::move(reason));
}

ANR分析步骤

源码

参考版本：14.0.0
http://aospxref.com/

xuanfengwuxiang
关注
  • 4
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android AMS原理分析（1）
leif 的博客
03-22 7655
AMS提供的主要功能： 统一调度各个应用程序的Activity。 应用程序需要启动Activity–>报告给AMS，决定是否可以启动–>如果可以，通知应用程序运行指定Activity。AMS必须知道各个应用程序运行的Activity。 内存管理。 Activity退出时不会立即被杀死，只有在内存紧张时才会自动被杀，这些操作由AMS管理。 进程管理。 AMS向外提供了查询系统正在运行的进程信息的API
ANR 原理及实践
little xian的博客
07-05 254
ANR 原理和分析
ANR问题原理介绍与DEBUG分析
漂流瓶の海岸
08-31 1322
介绍ANR触发的原理，LOG分析，以及部分问题示例
Android稳定性系列3　ANR的信息收集过程
liuwg1226的专栏
02-19 648
一　ANR场景 无论是四大组件或者进程等只要发生 ANR，最终都会调用 AMS.appNotResponding() 方法，下面从这个方法说起。 以下场景都会触发调用 AMS.appNotResponding 方法： Service Timeout：比如前台服务在20s内未执行完成； BroadcastQueue Timeout：比如前台广播在10s内未执行完成 InputDispatching Timeout：输入事件分发超时5s，包括按键和触摸事件。 frameworks/base/core/jav
ANR常见场景分析策略
cmyperson的博客
07-15 3768
定义 主线程在特定的时间内没有做完特定的事情 常见的场景 A.input事件超过5S没有处理完成 B.service executing 超时（bind，create，start，unbind等等），前台20s，后台200s C.广播处理超时，前台10S，后台60s D.ContentProvider执行超时，20s 常见的原因 A.耗时操作，如复杂的layout，庞大的for循环，IO等。 B.被Binder 对端block C.被子线程同步锁b
anr原理和全面分析
shuangrenlong的博客
02-16 1212
Android ANR：原理分析及解决办法 - 简书一、ANR说明和原因 1.1 简介 ANR全称：Application Not Responding，也就是应用程序无响应。 1.2 原因 Android系统中，Activi...https://www.jianshu.com/p/388166988cef
ANR问题产生原理和分析思路总结
内核工匠
07-05 1369
ANR问题是我们在开发中经常会遇到的问题。这种问题的发生往往是低概率并且难以复现，一旦发生就会给用户带来极差的体验。本文通过对ANR问题发生的原理、分析思路和案例的介绍，为分析ANR问题提供借鉴，帮助大家更好的理解和处理ANR问题。ANR问题即使应用响应超时问题，它根据发生的原因不同，主要分为KeyDispatchTimeout、BroadcastTimeout、ContentProviderTi...
ANR 原理简要分析
三木仔
09-25 1273
最近碰到ANR的问题，需要分析，啊，ANR的问题真的是难受，即使有trace.txt日志也无法看到端倪，ANR问题有时候真的需要随缘，而且会伴随着系统CPU占用过高、memory占用过多的现象，确实难以定位。 据此，花了一些时间学习Android ANR 问题的引发和系统如何检测ANR问题。 ANR问题简介 常见的ANR问题 Service ANR问题 InputEvent ANR...
Android ANR原理代码分析(二)
潇洒一刀的博客
04-19 1669
系统触发ANR机制 如系统显示ANR机制分析，都是通过appNotResponding来触发ANR对话框的显示，我们通过索引搜索可以发现，总共有五个地方可以产生这个调用，这5个调用正是引起ANR的5个原因。 com.android.server.am.ActivityManagerService#appNotRespondingViaProvider : ContentProvider 超时，目前没有使用。 com.android.server.am.ActiveServices#serviceFo
Android ANR机制的原理以及问题分析（一）
wcsbhwy的博客
05-13 2015
文章目录一、前言二、 ANR的类型三、臭名昭著的ANR 一、前言 Android开发人员对ANR应该毫不陌生——Application Not Responding，即应用程序未响应。ANR的核心原理是消息机制的调度和超时处理，它要求主线程在限定时间内做完任务处理，比如：启动Activity/Service、发送广播、ContentProvider查询、Input事件分发等，否则就可能发生ANR引起性能问题。处理超时时，系统会认为当前主线程已经失去响应其他操作的能力。这些耗时操作包括：密集的CPU运算、大量
【Android面试八股文】什么是ANR？如何分析和定位ANR？如何避免ANR？
字节卷动
07-02 762
是指Android系统在检测到应用程序主线程长时间阻塞而无法响应用户输入时触发的错误。当用户界面线程（UI线程）被阻塞超过一定时间限制时，系统会认为应用程序已经崩溃或停止响应，并显示一个强制关闭应用的对话框，以确保用户体验。
Android input 原理分析(七) _ input ANR 原理
私房菜
03-04 3543
​ 在 《原理分析(四)》 和《原理分析(六)》分析了input 整个分发过程，在input event 分发开始会给此次event 设定一个timeout，通常默认为 5s，如果在此时间内没有处理完此次event，InputDispatcher 将会抛出一个ANR。 本文集合《原理分析(四)》 和《原理分析(六)》分发过程来细致分析下input 中的ANR 产生和消除的原理，另外总结下input 中可能出现ANR 的种类和方式。
ANR超时种类及产生原因
一杯咖啡的专栏
05-10 8153
ANR产生原因及分类 ANR的产生需要同时满足三个条件 1.主线程：只有应用程序进程的主线程响应超时才会产生ANR； 2.超时时间：产生ANR的上下文不同，超时时间也不同，但只要超过这个时间上限没有响应就会产生ANR； 3.输入事件/特定操作：输入事件是指按键、触屏等设备输入事件，特定操作是指BroadcastReceiver和Service的生命周期中的各个函数调用。 产生ANR的上...
Android ANR排查手册
zhonglunshun的专栏
04-29 1万+
大部分做安卓的小伙伴相信对于ANR一定不陌生，相比于发生应用程序崩溃，发生ANR更加让人头大，主要原因是崩溃发生的时候会在Logcat中打印出发生异常的位置，开发人员很容易就能定位到崩溃并解决，显然ANR没那么轻松；但是我们大可不必这么忧伤，因为绝大部分ANR都是很容易解决的，只是我们没找到方法而已； 首先要搞定ANR就要对他有一个根本性的认识，和我们了解任何事物一样，只有抓住了事物之根本，才能在...
Android ANR 详解
热门推荐
fishmai的专栏
05-02 1万+
ANR简介 ANR，是“Application Not Responding”的缩写，即“应用程序无响应”。在Android中，ActivityManagerService（简称AMS）和WindowManagerService（简称WMS）会监测应用程序的响应时间，如果应用程序主线程（即UI线程）在超时时间内对输入事件没有处理完毕，或者对特定操作没有执行完毕，就会出现ANR。对于输入事件没
高德地图SDK Android版开发 10 InfoWindow
程序喵D的博客
09-06 1914
前文介绍高德地图添加Marker覆盖物的使用方法，Marker结合InfoWindow可展示更详尽的信息。本文将介绍以下内容：1. 使用SDK默认样式显示InfoWindow的方法；2. 自定义InfoWindow样式的方法。
从状态管理到性能优化：全面解析 Android Compose
最新发布
陆业聪
09-09 885
本文详细介绍了 Android Compose，一个现代化的 UI 框架，强调其声明式、简洁和可组合性的优势。文章探讨了状态管理、列表处理和性能优化，旨在帮助开发者有效利用 Compose 构建高效的 Android 应用。
4-1.Android Camera 之 CameraInfo 编码模板（前后置摄像头理解、摄像头图像的自然方向理解）
weixin_52173250的博客
09-05 1248
前置摄像头也是横向安装的，前置摄像头与后置摄像头的一个关键区别在于它在预览时会对图像进行镜像处理，即左右镜像处理把 orientation 为 270 处理成 orientation 为 90。大多数 Android 设备的后置摄像头是横向安装的，因此相机传感器采集的图像需要旋转才能与屏幕方向一致。：表示摄像头图像的自然方向（逆时针），通常会根据它在显示图像时对其进行适当的旋转。：表示设备的前置摄像头，手机屏幕上的。：表示摄像头镜头的方向，它的值可能是。：表示设备的后置摄像头，手机背后的。
Android ANR与DRAW_PENDING问题分析
ANR发生时，系统的logcat会输出相关的日志信息，同时也会生成一个trace文件，用于分析程序的执行路径和耗时，帮助开发者定位问题。 当应用程序启动时，它会在内存中申请buffer，这些buffer用于存储图像数据。buffer...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值