Android Framework层重启流程

最新推荐文章于 2025-02-07 16:52:43 发布
最新推荐文章于 2025-02-07 16:52:43 发布
阅读量2.3k 收藏 3
点赞数
分类专栏： Google 源码 && Framework

转载自http://gityuan.com/2016/07/09/android-reboot/

framework/base/services/core/java/com/android/server/power/PowerManagerServer.java
framework/base/services/core/java/com/android/server/power/ShutdownThread.java
一、概述
重启动作从按键触发中断，linux kernel层给Android framework层返回按键事件进入 framework层，再从 framework层到kernel层执行kernel层关机任务。当然还有非按键触发，比如系统异常导致重启，或者直接调用PM的reboot()方法重启。

这里就先从PowerManager说起。

二、关机流程
2.1 PM.reboot
[-> PowerManager.java]

public void reboot(String reason) {
try {
//【见小节2.2】
mService.reboot(false, reason, true);
} catch (RemoteException e) {
}
}
2.2 BinderService.reboot
[-> PowerManagerService.java]

private final class BinderService extends IPowerManager.Stub {
public void reboot(boolean confirm, String reason, boolean wait) {
//权限检查
mContext.enforceCallingOrSelfPermission(android.Manifest.permission.REBOOT, null);
if (PowerManager.REBOOT_RECOVERY.equals(reason)) {
mContext.enforceCallingOrSelfPermission(android.Manifest.permission.RECOVERY, null);
}

    final long ident = Binder.clearCallingIdentity();
    try {
        //【见小节2.3】
        shutdownOrRebootInternal(false, confirm, reason, wait);
    } finally {
        Binder.restoreCallingIdentity(ident);
    }
}

}
此时参数为shutdownOrRebootInternal(false, false, reason, true);

shutdown=false：代表重启；
confirm=false：代表直接重启，无需弹出询问提示框；
wait=true：代表阻塞等待重启操作完成。
2.3 PMS.shutdownOrRebootInternal
[-> PowerManagerService.java]

private void shutdownOrRebootInternal(final boolean shutdown, final boolean confirm,
final String reason, boolean wait) {
…
Runnable runnable = new Runnable() {
@Override
public void run() {
synchronized (this) {
if (shutdown) {
ShutdownThread.shutdown(mContext, reason, confirm);
} else {
//重启则进入该分支【见小节2.4】
ShutdownThread.reboot(mContext, reason, confirm);
}
}
}
};

// ShutdownThread必须运行在一个展现UI的looper
Message msg = Message.obtain(mHandler, runnable);
msg.setAsynchronous(true);
mHandler.sendMessage(msg);


if (wait) {
    //等待ShutdownThread执行完毕
    synchronized (runnable) {
        while (true) {
            try {
                runnable.wait();
            } catch (InterruptedException e) {
            }
        }
    }
}

}
2.4 SDT.reboot
[-> ShutdownThread.java]

public static void reboot(final Context context, String reason, boolean confirm) {
mReboot = true;
mRebootSafeMode = false;
mRebootUpdate = false;
mReason = reason;
//【见小节2.5】
shutdownInner(context, confirm);
}
mReboot为true则代表重启操作，值为false则代表关机操作。

2.5 SDT.shutdownInner
[-> ShutdownThread.java]

static void shutdownInner(final Context context, boolean confirm) {
//确保只有唯一的线程执行shutdown/reboot操作
synchronized (sIsStartedGuard) {
if (sIsStarted) {
return;
}
}

final int longPressBehavior = context.getResources().getInteger(
                com.android.internal.R.integer.config_longPressOnPowerBehavior);
final int resourceId = mRebootSafeMode
        ? com.android.internal.R.string.reboot_safemode_confirm
        : (longPressBehavior == 2
                ? com.android.internal.R.string.shutdown_confirm_question
                : com.android.internal.R.string.shutdown_confirm);

Log.d(TAG, "Notifying thread to start shutdown longPressBehavior=" + longPressBehavior);

if (confirm) {
    //这里是走弹出关机/重启提示框
    ...
} else {
    //本次confirm=false进入该分支【见小节2.6】
    beginShutdownSequence(context);
}

}
2.6 SDT.beginShutdownSequence
[-> ShutdownThread.java]

private static void beginShutdownSequence(Context context) {
synchronized (sIsStartedGuard) {
if (sIsStarted) {
return; //shutdown操作正在执行，则直接返回
}
sIsStarted = true;
}
//创建进度显示对话框
ProgressDialog pd = new ProgressDialog(context);

//当重启原因为"recovery"
if (PowerManager.REBOOT_RECOVERY.equals(mReason)) {
    mRebootUpdate = new File(UNCRYPT_PACKAGE_FILE).exists();
    if (mRebootUpdate) {
        pd.setTitle(context.getText(com.android.internal.R.string.reboot_to_update_title));
        pd.setMessage(context.getText(
                com.android.internal.R.string.reboot_to_update_prepare));
        pd.setMax(100);
        pd.setProgressNumberFormat(null);
        pd.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
        pd.setProgress(0);
        pd.setIndeterminate(false);
    } else {
        pd.setTitle(context.getText(com.android.internal.R.string.reboot_to_reset_title));
        pd.setMessage(context.getText(
                com.android.internal.R.string.reboot_to_reset_message));
        pd.setIndeterminate(true);
    }
} else {
    //重启/关机则进入该分支
    pd.setTitle(context.getText(com.android.internal.R.string.power_off));
    pd.setMessage(context.getText(com.android.internal.R.string.shutdown_progress));
    pd.setIndeterminate(true);
}
pd.setCancelable(false);
pd.getWindow().setType(WindowManager.LayoutParams.TYPE_KEYGUARD_DIALOG);

pd.show();

sInstance.mProgressDialog = pd;
sInstance.mContext = context;
sInstance.mPowerManager = (PowerManager)context.getSystemService(Context.POWER_SERVICE);

//确保系统不会进入休眠状态
sInstance.mCpuWakeLock = null;
try {
    sInstance.mCpuWakeLock = sInstance.mPowerManager.newWakeLock(
            PowerManager.PARTIAL_WAKE_LOCK, TAG + "-cpu");
    sInstance.mCpuWakeLock.setReferenceCounted(false);
    sInstance.mCpuWakeLock.acquire();
} catch (SecurityException e) {
    sInstance.mCpuWakeLock = null;
}

//当处理亮屏状态，则获取亮屏锁，提供用户体验
sInstance.mScreenWakeLock = null;
if (sInstance.mPowerManager.isScreenOn()) {
    try {
        sInstance.mScreenWakeLock = sInstance.mPowerManager.newWakeLock(
                PowerManager.FULL_WAKE_LOCK, TAG + "-screen");
        sInstance.mScreenWakeLock.setReferenceCounted(false);
        sInstance.mScreenWakeLock.acquire();
    } catch (SecurityException e) {
        sInstance.mScreenWakeLock = null;
    }
}

sInstance.mHandler = new Handler() {};
//启动线程来执行shutdown初始化【见小节2.7】
sInstance.start();

}
此处ProgressDialog根据不同reboot reason会不同UI框：

重启到recovery模式，并安装更新
Condition：mReason == REBOOT_RECOVERY and mRebootUpdate == True
检查/cache/recovery/uncrypt_file文件存在，则mRebootUpdate为True
UI: 进度条(progress bar)
重启到recovery，用于工厂重置模式
Condition: mReason == REBOOT_RECOVERY and mRebootUpdate == False
UI: 仅显示spinning circle
常规重启/关机
Condition: Otherwise
UI: 仅显示spinning circle
2.7 SDT.run
[-> ShutdownThread.java]

public final class ShutdownThread extends Thread {
public void run() {
BroadcastReceiver br = new BroadcastReceiver() {
public void onReceive(Context context, Intent intent) {
//接收到该广播,则唤醒wait()操作
actionDone();
}
};

    //设置属性"sys.shutdown.requested"的值为reason
    String reason = (mReboot ? "1" : "0") + (mReason != null ? mReason : "");
    SystemProperties.set(SHUTDOWN_ACTION_PROPERTY, reason);

    if (mRebootSafeMode) {
        //如果需要重启进入安全模式，则设置"persist.sys.safemode"=1
        SystemProperties.set(REBOOT_SAFEMODE_PROPERTY, "1");
    }

    //1. 发送关机广播
    mActionDone = false;
    Intent intent = new Intent(Intent.ACTION_SHUTDOWN);
    intent.addFlags(Intent.FLAG_RECEIVER_FOREGROUND);
    mContext.sendOrderedBroadcastAsUser(intent,
            UserHandle.ALL, null, br, mHandler, 0, null, null);
    //其中MAX_BROADCAST_TIME=10s
    final long endTime = SystemClock.elapsedRealtime() + MAX_BROADCAST_TIME;

    //循环等待,超时或者mActionDone都会结束该循环
    synchronized (mActionDoneSync) {
        while (!mActionDone) {
            long delay = endTime - SystemClock.elapsedRealtime();
            if (delay <= 0) {
                break; //关机广播超时
            } else if (mRebootUpdate) {
                int status = (int)((MAX_BROADCAST_TIME - delay) * 1.0 *
                        BROADCAST_STOP_PERCENT / MAX_BROADCAST_TIME);
                sInstance.setRebootProgress(status, null);
            }
            try {
                //最长等待时间为500ms
                mActionDoneSync.wait(Math.min(delay, PHONE_STATE_POLL_SLEEP_MSEC));
            } catch (InterruptedException e) {
            }
        }
    }
    if (mRebootUpdate) {
        sInstance.setRebootProgress(BROADCAST_STOP_PERCENT, null);
    }

    final IActivityManager am =
        ActivityManagerNative.asInterface(ServiceManager.checkService("activity"));
    if (am != null) {
        //2. 关闭AMS [见流程2.7.1]
        am.shutdown(MAX_BROADCAST_TIME);
    }
    if (mRebootUpdate) {
        sInstance.setRebootProgress(ACTIVITY_MANAGER_STOP_PERCENT, null);
    }

    final PackageManagerService pm = (PackageManagerService)
        ServiceManager.getService("package");
    if (pm != null) {
        //3. 关闭PMS [见流程2.7.2]
        pm.shutdown();
    }
    if (mRebootUpdate) {
        sInstance.setRebootProgress(PACKAGE_MANAGER_STOP_PERCENT, null);
    }

    //4. 关闭radios [见流程2.7.3]
    shutdownRadios(MAX_RADIO_WAIT_TIME);
    if (mRebootUpdate) {
        sInstance.setRebootProgress(RADIO_STOP_PERCENT, null);
    }

    IMountShutdownObserver observer = new IMountShutdownObserver.Stub() {
        public void onShutDownComplete(int statusCode) throws RemoteException {
            actionDone();
        }
    };

    mActionDone = false;
    //其中MAX_SHUTDOWN_WAIT_TIME=20s
    final long endShutTime = SystemClock.elapsedRealtime() + MAX_SHUTDOWN_WAIT_TIME;
    synchronized (mActionDoneSync) {
        final IMountService mount = IMountService.Stub.asInterface(
                ServiceManager.checkService("mount"));
        if (mount != null) {
            //5. 关闭MountService [见流程2.7.3]
            mount.shutdown(observer);
        }
        while (!mActionDone) {
            long delay = endShutTime - SystemClock.elapsedRealtime();
            if (delay <= 0) {
                break; // Mount观察者广播超时
            } else if (mRebootUpdate) {
                int status = (int)((MAX_SHUTDOWN_WAIT_TIME - delay) * 1.0 *
                        (MOUNT_SERVICE_STOP_PERCENT - RADIO_STOP_PERCENT) /
                        MAX_SHUTDOWN_WAIT_TIME);
                status += RADIO_STOP_PERCENT;
                sInstance.setRebootProgress(status, null);
            }
            try {
                //当收到mActionDoneSync.notifyAll()，则继续往下执行程序
                mActionDoneSync.wait(Math.min(delay, PHONE_STATE_POLL_SLEEP_MSEC));
            } catch (InterruptedException e) {
            }
        }
    }
    ...
    //【见流程2.8】
    rebootOrShutdown(mContext, mReboot, mReason);
}

}
设置”sys.shutdown.requested”，记录下mReboot和mReason。如果是进入安全模式，则”persist.sys.safemode=1”。

接下来主要关闭一些系统服务：

发送关机广播
关闭AMS
关闭PMS
关闭radios
关闭MountService
之后就需要进入重启/关机流程。

2.7.1 AMS.shutdown
通过AMP.shutdown，通过binder调用到AMS.shutdown.

public boolean shutdown(int timeout) {
//权限检测
if (checkCallingPermission(android.Manifest.permission.SHUTDOWN)
!= PackageManager.PERMISSION_GRANTED) {
throw new SecurityException(“Requires permission ”
+ android.Manifest.permission.SHUTDOWN);
}

boolean timedout = false;

synchronized(this) {
    mShuttingDown = true;
    //禁止WMS继续处理Event
    updateEventDispatchingLocked();
    //调用ASS处理shutdown操作
    timedout = mStackSupervisor.shutdownLocked(timeout);
}

mAppOpsService.shutdown();
if (mUsageStatsService != null) {
    mUsageStatsService.prepareShutdown();
}
mBatteryStatsService.shutdown();
synchronized (this) {
    mProcessStats.shutdownLocked();
    notifyTaskPersisterLocked(null, true);
}

return timedout;

}
此处timeout为MAX_BROADCAST_TIME=10s

2.7.2 PMS.shutdown
public void shutdown() {
mPackageUsage.write(true);
}
此处mPackageUsage数据类型是PMS的内部类PackageUsage。

private class PackageUsage {
void write(boolean force) {
if (force) {
writeInternal();
return;
}
…
}
}
对于force=true，接下来调用writeInternal方法。

private class PackageUsage {
private void writeInternal() {
synchronized (mPackages) {
synchronized (mFileLock) {
//file是指/data/system/package-usage.list
AtomicFile file = getFile();
FileOutputStream f = null;
try {
//将原来的文件记录到package-usage.list.bak
f = file.startWrite();
BufferedOutputStream out = new BufferedOutputStream(f);
FileUtils.setPermissions(file.getBaseFile().getPath(), 0640, SYSTEM_UID, PACKAGE_INFO_GID);
StringBuilder sb = new StringBuilder();
for (PackageParser.Package pkg : mPackages.values()) {
if (pkg.mLastPackageUsageTimeInMills == 0) {
continue;
}
sb.setLength(0);
sb.append(pkg.packageName);
sb.append(’ ‘);
sb.append((long)pkg.mLastPackageUsageTimeInMills);
sb.append(‘\n’);
out.write(sb.toString().getBytes(StandardCharsets.US_ASCII));
}
out.flush();
//将文件内容同步到磁盘，并删除.bak文件
file.finishWrite(f);
} catch (IOException e) {
if (f != null) {
file.failWrite(f);
}
Log.e(TAG, “Failed to write package usage times”, e);
}
}
}
mLastWritten.set(SystemClock.elapsedRealtime());
}
}
/data/system/package-usage.list文件中每一行记录一条package及其上次使用时间(单位ms)。

由于IO操作的过程中，写入文件并非立刻就会真正意义上写入物理磁盘，以及在写入文件的过程中还可能中断或者出错等原因的考虑，采用的策略是先将老的文件package-usage.list，重命为增加后缀package-usage.list.bak；然后再往package-usage.list文件写入新的数据，数据写完之后再执行sync操作，将内存数据彻底写入物理磁盘，此时便可以安全地删除原来的package-usage.list.bak文件。

2.7.3 ST.shutdownRadios
[-> ShutdownThread.java]

private void shutdownRadios(final int timeout) {
final long endTime = SystemClock.elapsedRealtime() + timeout;
Thread t = new Thread() {
public void run() {
boolean nfcOff;
boolean bluetoothOff;
boolean radioOff;

        final INfcAdapter nfc =
                INfcAdapter.Stub.asInterface(ServiceManager.checkService("nfc"));
        final ITelephony phone =
                ITelephony.Stub.asInterface(ServiceManager.checkService("phone"));
        final IBluetoothManager bluetooth =
                IBluetoothManager.Stub.asInterface(ServiceManager.checkService(
                        BluetoothAdapter.BLUETOOTH_MANAGER_SERVICE));

        nfcOff = nfc == null || nfc.getState() == NfcAdapter.STATE_OFF;
        if (!nfcOff) {
            nfc.disable(false);//关闭NFC
        }

        bluetoothOff = bluetooth == null || !bluetooth.isEnabled();
        if (!bluetoothOff) {
            bluetooth.disable(false);  //关闭Bluetooth
        }

        radioOff = phone == null || !phone.needMobileRadioShutdown();
        if (!radioOff) {
            phone.shutdownMobileRadios(); //关闭cellular radios
        }
        ...

        //等待NFC, Bluetooth, Radio
        long delay = endTime - SystemClock.elapsedRealtime();
        while (delay > 0) {
            ...
            if (radioOff && bluetoothOff && nfcOff) {
                Log.i(TAG, "NFC, Radio and Bluetooth shutdown complete.");
                break;
            }
            //每间隔500ms，check一次，直到nfc、bluetooth、radio全部关闭或者超时才会退出循环
            SystemClock.sleep(PHONE_STATE_POLL_SLEEP_MSEC);
            delay = endTime - SystemClock.elapsedRealtime();
        }
    }
};

t.start();
try {
    t.join(timeout);
} catch (InterruptedException ex) {
}

}
创建新的线程来处理NFC, Radio and Bluetooth这些射频相关的模块的shutdown过程。每间隔500ms，check一次，直到nfc、bluetooth、radio全部关闭或者超时(MAX_RADIO_WAIT_TIME=12s)才会退出循环。

2.7.4 MS.shutdown
[-> MountService.java]

public void shutdown(final IMountShutdownObserver observer) {
enforcePermission(android.Manifest.permission.SHUTDOWN);
//向名为“MountService”的线程发送H_SHUTDOWN消息
mHandler.obtainMessage(H_SHUTDOWN, observer).sendToTarget();
}
MountService线程收到消息后进入handleMessage出来相应消息

class MountServiceHandler extends Handler {
public void handleMessage(Message msg) {
switch (msg.what) {
case H_SHUTDOWN: {
final IMountShutdownObserver obs = (IMountShutdownObserver) msg.obj;
boolean success = false;
try {
//向vold发送shutdown命令
success = mConnector.execute(“volume”, “shutdown”).isClassOk();
} catch (NativeDaemonConnectorException ignored) {
}
if (obs != null) {
try {
//回调方法，告知关闭工作已完成
obs.onShutDownComplete(success ? 0 : -1);
} catch (RemoteException ignored) {
}
}
break;
}
…
}
}
}
observer的回调方法onShutDownComplete()，会调用actionDone()，该方法通知mActionDoneSync已完成

void actionDone() {
synchronized (mActionDoneSync) {
mActionDone = true;
mActionDoneSync.notifyAll();
}
}
调用mActionDoneSync.notifyAll()之后，那么便可以继续往下执行rebootOrShutdown方法。

2.8 SDT.rebootOrShutdown
[-> ShutdownThread.java]

public static void rebootOrShutdown(final Context context, boolean reboot, String reason) {
if (reboot) {
Log.i(TAG, “Rebooting, reason: ” + reason);
//【见小节2.9】
PowerManagerService.lowLevelReboot(reason);
Log.e(TAG, “Reboot failed, will attempt shutdown instead”);
reason = null;
} else if (SHUTDOWN_VIBRATE_MS > 0 && context != null) {
…
}

//关闭电源 [见流程2.10]
PowerManagerService.lowLevelShutdown(reason);

}
对于重启原因:

logcat会直接输出Rebooting, reason: ;
如果重启失败，则会输出Reboot failed; ，- 果无法重启，则会尝试直接关机。
2.9 PMS.lowLevelReboot
public static void lowLevelReboot(String reason) {
if (reason == null) {
reason = “”;
}
if (reason.equals(PowerManager.REBOOT_RECOVERY)) {
SystemProperties.set(“ctl.start”, “pre-recovery”);
} else {
SystemProperties.set(“sys.powerctl”, “reboot,” + reason);
}
try {
Thread.sleep(20 * 1000L);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
Slog.wtf(TAG, “Unexpected return from lowLevelReboot!”);
}
当reboot原因是“recovery”，则设置属性ctl.start=pre-recovery；
当其他情况，则设置属性”sys.powerctl=reboot,[reason]”。
到此，framework层面的重启就流程基本介绍完了，那么接下来就要进入属性服务，即设置sys.powerctl=reboot,。

三、总结
先用一句话总结，从最开始的PM.reboot()，经过层层调用，最终重启的核心方法等价于调用SystemProperties.set(“sys.powerctl”, “reboot,” + reason); 也就意味着调用下面命令，也能重启手机：

adb shell setprop sys.powerctl reboot

Reboot framework 安装 和注意事项
主攻大数据 人工智能 物联网 安全 低空经济等方向。mtsc 、gtest特邀分享嘉宾
05-04 2541
资料提供： 1.http://www.testclass.net/rf/ 使用Rebootframwork时基于python 的安装python环境 至于怎样安装大致流程： 1.官网下载 2.点击运行 3.设置环境变量 4.安装编写工具pycharm 安装rebootframwork的大致流程： 前提条件：python安装成功 ！检验是否安装成功Pythonversi...
RK3568平台开发系列讲解（安卓篇）Android关机Framework 代码流程
内核笔记
10-23 2690
简述代码调用PowerManager.shutdown()代码流程
Android 手机重启相关内容
程序员Android
05-30 1915
极力推荐Android 开发大总结文章：欢迎收藏程序员Android 力荐 ，Android 开发者需要的必备技能   本篇文章主要介绍 Android 开发中的部分知识点，通过阅读本篇文章，您将收获以下内容: 1.MTK 平台AEE 搜集重启问题介绍 2.SWT 导致手机重启问题分析 3.快速分析归类重启问题 4.部分手机重启问题解决方案 欢迎关注微信公众号:程序员An...
Android Framework 初级教程
最新发布
知识深度终结
02-07 1599
Android Framework 是 Android 操作系统的核心部分，它提供了开发 Android 应用程序所需的基础组件和 API。Android Framework 包括四大组件（Activity、Service、BroadcastReceiver、ContentProvider）以及其他重要的系统服务（如 WindowManager、PackageManager、ActivityManager 等）。
重启framework命令及framework.jar引用(十五)
Android系统攻城狮
04-14 1910
1、重启framwork命令 # adb shell start //启动framework # adb shell stop //停止framework or # adb shell am restart //重启framework # adb shell am kill-all //杀死后台所有进程 # adb shell am force-stop 包名 //强杀进程 //参考 am ...
Android笔记 - Android启动之Android Framework启动
yansha的专栏
12-08 1645
init 进程进入 main 函数后，主要完成以下四项工作。第一，在根文件系统中创建目录作为挂载点，然后挂载虚拟文件系统；第二， 解析启动脚本文件 init.rc；第三，根据启动脚本 init.rc 的解析结果开启 Android Framework 核心服务进程；第四，监听事件，重启服务。
Android 手机关机流程及异常分析
程序员Android
05-22 6153
极力推荐Android 开发大总结文章：欢迎收藏程序员Android 力荐 ，Android 开发者需要的必备技能   本篇文章主要介绍 Android 开发中的 关机 部分知识点，通过阅读本篇文章，您将收获以下内容: 1.如何初步定位异常关机问题 2.关机流程上层浅析 欢迎关注微信公众号:程序员Android 公众号ID：ProgramAndroid 获取更多信息 ...
Android Framework SIM卡PIN码解锁代码流程
zmlovelx(帅得不敢出门 程序员群31843264)
10-26 1402
SIM卡打开PIN码锁定后，插入SIM卡，或插入后重启手机，会弹出一个锁定窗口，要求输入PIN码解锁手机屏幕。本文讲述是安卓Framework中的代码是如何实现这个锁定与解锁的。。SIM PIN解锁主要是通过verifyPasswordAndUnlock()函数实现的，它会对输入的PIN码进行校验，如果不对会提示错误，如果正确解锁窗口会自动消失进入系统。
Android Framework学习——安卓系统启动流程（Android 13）
qq_31190665的博客
12-25 1974
提示：本文仅作个人学习记录，禁止转载无论是安卓应用开发，还是安卓framework开发，在面试中总是会被问到framework相关的知识，系统启动流程已然成为高频提问点之一，以前对系统启动流程的认识停留在其他人口口相传、博客上的简要总结及流程图，接下来我将根据源码主要流程进行梳理，总结安卓系统启动这一过程的主要步骤。因为关注的重点是Java API Framework层的流程（如下图绿色部分），所以在这之前的流程会简略概括。在关机状态长按电源键，引导芯片程序（固化在rom中）开始运行；
Android Framework AMS（12）广播组件分析-3（广播发送流程解读）
wangdsh的博客
11-06 1360
说明：本章节主要解读广播组件的广播发送过程。关注思维导图中左侧部分即可。有了前面广播组件 注册和注销程分析的基础，基于此，接下来我们来分析广播组件的发送广播流程。我们先对广播组件的整体设计思路有一个了解，再详细分析其广播发送关键流程。
Android Framework AMS（09）service组件分析-3(bindService和unbindService关键流程分析)
wangdsh的博客
10-17 1286
说明：上上一章节主要解读应用层service组件启动的2种方式startService和bindService，以及从APP层到AMS调用之间的打通。上一章节我们关注了service组件启动方式的一种：startService启动方式。本章节主要关注service组件启动方式的另一种：bindService启动方式，分析关键API为service组件的bindService和unbindService方法。AMS.bindService->service组件onCreate、onBind。
android framework 重启LOG分析方法
Blue_Apples的博客
09-18 845
http://www.2cto.com/kf/201202/119406.html http://blog.youkuaiyun.com/songjinshi/article/details/46730665
android camera HAL 错误数据流处理
icamera0的博客
01-23 2959
1.        Error management 如果发生严重的错误，有返回值的camera HAL层设备操作函数将统一返回-ENODEV / NULL。这意味着这个设备不能继续操作了，必须被framework层关闭。一旦通过某种方式返回了这个错误，或者使用notify()发送了ERROR_DEVICE，那就只有close()函数才能被成功地调用。其他所有函数将都会返回-ENODEV /
Android start stop 重启framework
dk_work的博客
03-10 2348
使用stop start命令来重启framework，我们来看下其代码 是在system/core/toolbox下面,原理很简单就是利用ctl属性来控制进程。 start.c [cpp] view plain copy #include   #include   #include     #include     int start_main(int argc,
Android系统升级全流程
变
04-22 7142
Recovery模块总结（正常模式下，升级的处理流程） 前段时间负责公司项目的系统升级模块开发，在开发过程中，对整个升级流程有个基本的了解，现在此做一个阶段性的总结，方便日后查阅。项目基于高通Android 7.0.1实现， 主要有以下内容： 正常模式下，升级的处理流程 Recovery模式下，升级处理流程 完整包与增量包的制作 其他模块的升级（单片机） Recovery的UI显示 基本概念 ...
android 定时重启设备
通信侠的博客
07-18 1153
本文主要介绍一种定时重启设备的方案，目的是对于低内存设备，防止其由于长时间不关机且应用消耗过多RAM导致卡顿甚至无法开机的现象。基本方案是通过AlarmManager设置定时闹钟唤醒系统并且判断是否符合重启条件，从而进行弹框提醒和倒计时重启。
安卓开发学习之SystemServer启动过程
四国棋客
07-03 1913
背景这两天有一个需求得联调，在等待服务端同事完事，等待过程中，阅读了一下Android8.0里SystemServer的启动过程，除了设置时区语言这些，其实主要就是初始化了系统上下文以及一些服务的启动。main()方法SystemServer是一个进程，由zygote进程fork出来，所以它的入口方法就是main方法，代码如下 public static void main(String[]...
mContext.enforceCallingOrSelfPermission
jason的笔记
08-03 7641
mContext.enforceCallingOrSelfPermission(android.Manifest.permission.BIND_APPWIDGET, null); 大家经常会看到上面这句话在runtime是check 权限，具体是怎么实现的呢？ xref: /frameworks/base/core/java/android/app/ContextImpl.java 156
Android JB的reboot流程
godisagirl2的专栏
03-12 2189
JB的Power的source比起之前的版本有有了一些改動，不過總的來說整個流程還是沒有怎麼變，只是一些文件和路徑變了。沒有辦法，剛看完一個部份的代碼，Google又在新的版本中做了改動，唯一的辦法就只能是把代碼的思路和流程弄清，至于code是怎麼碼的是其實，因為代碼是不斷的變而思想一般來說變化并不是那么大。今天就把power部份的reboot的一個流程給理一下。Shutdonw和reboot其實
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值