Android DropBox模块笔记

/data/system/dropbox # ls -thl
total 36K
-rw------- 1 system system 2.2K 2022-10-03 18:27 system_server_wtf@1639267200804.txt
-rw------- 1 system system 1.8K 2022-10-03 18:27 system_app_wtf@1639267200803.txt
-rw------- 1 system system 1.6K 2022-10-03 18:27 system_app_strictmode@1639267200802.txt
-rw------- 1 system system 1.8K 2022-10-03 18:27 system_server_strictmode@1639267200801.txt
-rw------- 1 system system 1.3K 2022-10-03 18:27 system_server_strictmode@1639267200800.txt
-rw------- 1 system system 1.3K 2022-10-03 18:27 system_server_strictmode@1639267200799.txt
-rw------- 1 system system 1.2K 2022-10-03 18:27 system_server_strictmode@1639267200798.txt
-rw------- 1 system system 1.2K 2022-10-03 18:27 system_server_strictmode@1639267200797.txt
-rw------- 1 system system 1.2K 2022-10-03 18:27 system_server_strictmode@1639267200796.txt
-rw------- 1 system system 1.8K 2022-10-03 18:27 system_server_strictmode@1639267200795.txt
-rw------- 1 system system 1.5K 2022-10-03 18:27 system_server_strictmode@1639267200793.txt
-rw------- 1 system system 1.5K 2022-10-03 18:27 system_server_strictmode@1639267200794.txt
-rw------- 1 system system 1.2K 2022-10-03 18:27 system_server_strictmode@1639267200791.txt
-rw------- 1 system system 1.5K 2022-10-03 18:27 system_server_strictmode@1639267200792.txt
-rw------- 1 system system 1.8K 2021-12-12 08:59 system_server_wtf@1639270794860.txt
-rw------- 1 system system 1.8K 2021-12-12 08:29 system_server_wtf@1639268994862.txt
-rw------- 1 system system 1.8K 2021-12-12 08:00 system_server_wtf@1639267254499.txt
-rw------- 1 system system  557 2021-12-12 08:00 SYSTEM_BOOT@1639267200805.txt

frameworks/base/core/java/android/os/DropBoxManager.java 
frameworks/base/core/java/android/os/DropBoxManager.aidl

frameworks/base/core/java/com/android/internal/os/IDropBoxManagerService.aidl

frameworks/base/services/core/java/com/android/server/DropBoxManagerService.java 

frameworks/base/libs/services/include/android/os/DropBoxManager.h
frameworks/base/libs/services/src/os/DropBoxManager.cpp

private void startOtherServices() {
    ...
            traceBeginAndSlog("StartDropBoxManager");
            mSystemServiceManager.startService(DropBoxManagerService.class);
            traceEnd();
    ...
}

//frameworks/base/services/core/java/com/android/server/DropBoxManagerService.java
   public DropBoxManagerService(final Context context) {
       //创建File对象，并非创建文件
        this(context, new File("/data/system/dropbox"), FgThread.get().getLooper());
    }

    @VisibleForTesting
    public DropBoxManagerService(final Context context, File path, Looper looper) {
        super(context);
        //全局对象，定义private final File mDropBoxDir，此处进行赋值
        mDropBoxDir = path;
        //PS:ContentResolver直译为内容解析器,和ContentProvider成对出现。
        //程序间数据的共享是通过Provider/Resolver进行的。提供数据（内容）的就叫Provider，Resovler提供接口对这个内容进行解读
        mContentResolver = getContext().getContentResolver();
        //创建handler对象
        mHandler = new DropBoxManagerBroadcastHandler(looper);
    }

   private class DropBoxManagerBroadcastHandler extends Handler {
        static final int MSG_SEND_BROADCAST = 1;
        static final int MSG_SEND_DEFERRED_BROADCAST = 2;
       .....
       //构造函数
        DropBoxManagerBroadcastHandler(Looper looper) {
            super(looper);
        }
        //处理消息函数
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case MSG_SEND_BROADCAST://正常广播
                    prepareAndSendBroadcast((Intent) msg.obj);
                    break;
                case MSG_SEND_DEFERRED_BROADCAST://延时广播
                    Intent deferredIntent;
                    synchronized (mLock) {
                        deferredIntent = mDeferredMap.remove((String) msg.obj);
                    }
                    if (deferredIntent != null) {
                        prepareAndSendBroadcast(deferredIntent);
                    }
                    break;
            }
        }

        private void prepareAndSendBroadcast(Intent intent) {
            if (!DropBoxManagerService.this.mBooted) {
                intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY);
            }
            getContext().sendBroadcastAsUser(intent, UserHandle.SYSTEM,
                    android.Manifest.permission.READ_LOGS);
        }

# logcat |grep -Ei "BootPhase|Starting phase"
01-01 08:00:10.953  2678  2678 I SystemServiceManager: Starting phase 100
01-01 08:00:11.005  2678  2678 W SystemServiceManager: Service com.android.server.display.DisplayManagerService took 52 ms in onBootPhase
10-03 18:27:31.494  2678  2678 I SystemServer: StartBootPhaseLockSettingsReady
10-03 18:27:31.494  2678  2678 I SystemServiceManager: Starting phase 480
10-03 18:27:31.502  2678  2678 D SystemServerTiming: StartBootPhaseLockSettingsReady took to complete: 8ms
//dropbox服务的onBootPhase函数在这个范围执行
10-03 18:27:31.502  2678  2678 I SystemServer: StartBootPhaseSystemServicesReady
10-03 18:27:31.502  2678  2678 I SystemServiceManager: Starting phase 500
10-03 18:27:31.554  2678  2678 D ContextHubSystemService: onBootPhase: PHASE_SYSTEM_SERVICES_READY
10-03 18:27:31.555  2678  2678 D SystemServerTiming: StartBootPhaseSystemServicesReady took to complete: 53ms
10-03 18:27:31.598  2678  2678 I SystemServer: StartBootPhaseDeviceSpecificServicesReady
10-03 18:27:31.598  2678  2678 I SystemServiceManager: Starting phase 520
10-03 18:27:31.598  2678  2678 D SystemServerTiming: StartBootPhaseDeviceSpecificServicesReady took to complete: 0ms
10-03 18:27:31.656  2678  2678 I SystemServiceManager: Starting phase 550
10-03 18:27:31.805  2678  2678 I SystemServiceManager: Starting phase 600
10-03 18:27:31.823  2678  2678 D CarServiceHelper: onBootPhase:600
10-03 18:27:32.935  2678  2749 I SystemServiceManager: Starting phase 1000
10-03 18:27:32.957  2678  2749 D CarServiceHelper: onBootPhase:1000

//PHASE_LOCK_SETTINGS_READY=480
//PHASE_SYSTEM_SERVICES_READY=500
        traceBeginAndSlog("StartBootPhaseLockSettingsReady");
        mSystemServiceManager.startBootPhase(SystemService.PHASE_LOCK_SETTINGS_READY);
        traceEnd();

        traceBeginAndSlog("StartBootPhaseSystemServicesReady");
        mSystemServiceManager.startBootPhase(SystemService.PHASE_SYSTEM_SERVICES_READY);
        traceEnd();

//frameworks/base/services/core/java/com/android/server/DropBoxManagerService.java
    @Override
    public void onBootPhase(int phase) {
        switch (phase) {
            case PHASE_SYSTEM_SERVICES_READY:
                IntentFilter filter = new IntentFilter();
                filter.addAction(Intent.ACTION_DEVICE_STORAGE_LOW);
                getContext().registerReceiver(mReceiver, filter);
                //注册Observer，通过指定Uri可以仅对数据库中感兴趣的数据有变化时，进行监听
                mContentResolver.registerContentObserver(
                    Settings.Global.CONTENT_URI, true,
                    new ContentObserver(new Handler()) {
                        @Override
                        public void onChange(boolean selfChange) {
                            mReceiver.onReceive(getContext(), (Intent) null);
                        }
                    });
                //低优先级(frameworks/base/core/res/res/values/config.xml)
                //config_dropboxLowPriorityBroadcastRateLimitPeriod=2000
                //config_dropboxLowPriorityTags
                getLowPriorityResourceConfigs();
                break;
            //启动完成后设置mBooted属性
            case PHASE_BOOT_COMPLETED:
                mBooted = true;
                break;
        }
    }

//DropBoxManager.java
    public void addText(String tag, String data) {
        try {
            //调用IDropBoxManagerService的add函数，到service层
            //入参entry类型
            mService.add(new Entry(tag, 0, data));
        } catch (RemoteException e) {
            if (e instanceof TransactionTooLargeException
                    && mContext.getApplicationInfo().targetSdkVersion < Build.VERSION_CODES.N) {
                Log.e(TAG, "App sent too much data, so it was ignored", e);
                return;
            }
            throw e.rethrowFromSystemServer();
        }
    }

       /** Create a new Entry with plain text contents. */
        public Entry(String tag, long millis, String text) {
            if (tag == null) throw new NullPointerException("tag == null");
            if (text == null) throw new NullPointerException("text == null");

            mTag = tag;
            mTimeMillis = millis;
            mData = text.getBytes();
            mFileDescriptor = null;
            mFlags = IS_TEXT;
        }

//DropBoxManagerService.java
//调用DropBoxManagerService的add函数
 private final IDropBoxManagerService.Stub mStub = new IDropBoxManagerService.Stub() {
        @Override
        public void add(DropBoxManager.Entry entry) {
            DropBoxManagerService.this.add(entry);
        }
        ....
 }

# logcat |grep -Ei "isTagEnabled"
10-03 18:27:30.993  2678  2748 I DropBoxManagerService: add tag=system_server_strictmode isTagEnabled=true flags=0x2
10-03 18:27:31.050  2678  2748 I DropBoxManagerService: add tag=system_server_strictmode isTagEnabled=true flags=0x2
10-03 18:27:33.509  2678  3459 I DropBoxManagerService: add tag=system_app_wtf isTagEnabled=true flags=0x2
10-03 18:27:34.366  2678  2748 I DropBoxManagerService: add tag=system_app_strictmode isTagEnabled=true flags=0x2
10-03 18:27:36.926  2678  2851 I DropBoxManagerService: add tag=system_server_wtf isTagEnabled=true flags=0x2
12-12 08:00:00.282  2678  3941 I DropBoxManagerService: add tag=SYSTEM_BOOT isTagEnabled=true flags=0x2
12-12 08:00:54.426  2678  2849 I DropBoxManagerService: add tag=system_server_wtf isTagEnabled=true flags=0x2
12-12 08:29:54.778  2678  2849 I DropBoxManagerService: add tag=system_server_wtf isTagEnabled=true flags=0x2

 public void add(DropBoxManager.Entry entry) {
        File temp = null;
        InputStream input = null;
        OutputStream output = null;
        //获取日志tag标签信息
        final String tag = entry.getTag();
        try {
            int flags = entry.getFlags();
            Slog.i(TAG, "add tag=" + tag + " isTagEnabled=" + isTagEnabled(tag)
                    + " flags=0x" + Integer.toHexString(flags));
            if ((flags & DropBoxManager.IS_EMPTY) != 0) throw new IllegalArgumentException();
            //调用init函数，主要是创建EntryFile即日志文件  --> new EntryFile(file, mBlockSize)
            //如果文件存在，则调用enrollEntry(entry)
            init();
            //检查tag是否启动
            if (!isTagEnabled(tag)) return;
            //修剪磁盘上的文件以确保它们不会占用太多空间
            long max = trimToFit();
            long lastTrim = System.currentTimeMillis();
            //创建buffer
            byte[] buffer = new byte[mBlockSize];
            input = entry.getInputStream();

            // 首先，在决定是否压缩数据之前，在内存中累积最多一块数据
            int read = 0;
            while (read < buffer.length) {
                int n = input.read(buffer, read, buffer.length - read);
                if (n <= 0) break;
                read += n;
            }

            //如果我们至少有一个块，就压缩它——否则，只需以未压缩的形式写入数据
            //临时文件
            temp = new File(mDropBoxDir, "drop" + Thread.currentThread().getId() + ".tmp");
            int bufferSize = mBlockSize;
            if (bufferSize > 4096) bufferSize = 4096;
            if (bufferSize < 512) bufferSize = 512;
            FileOutputStream foutput = new FileOutputStream(temp);
            output = new BufferedOutputStream(foutput, bufferSize);
            if (read == buffer.length && ((flags & DropBoxManager.IS_GZIPPED) == 0)) {
                output = new GZIPOutputStream(output);
                flags = flags | DropBoxManager.IS_GZIPPED;
            }

            do {
                //写入buffer数据到文件
                output.write(buffer, 0, read);
                //时间戳判断，以防数据缓慢流入
                long now = System.currentTimeMillis();
                if (now - lastTrim > 30 * 1000) {
                    max = trimToFit();  
                    lastTrim = now;
                }

                read = input.read(buffer);
                //获得最终尺寸测量
                if (read <= 0) {
                    FileUtils.sync(foutput);
                    output.close();  // Get a final size measurement
                    output = null;
                } else {
                    //所以尺寸测量是伪合理的
                    output.flush();  // So the size measurement is pseudo-reasonable
                }

                long len = temp.length();
                if (len > max) {
                    Slog.w(TAG, "Dropping: " + tag + " (" + temp.length() + " > "
                            + max + " bytes)");
                    temp.delete();
                    temp = null;  // Pass temp = null to createEntry() to leave a tombstone
                    break;
                }
            } while (read > 0);
            //将临时文件移动到最终日志文件名并注册
            long time = createEntry(temp, tag, flags);
            temp = null;

            //在此调用返回后调用sendBroadcast以避免死锁。
            //特别是，调用方可能持有WindowManagerService锁，但sendBroadcast需要ActivityManagerService中的锁。
            //ActivityManagerService在等待WindowManagerService锁定时被发现持有该锁定。
            if (mLowPriorityTags != null && mLowPriorityTags.contains(tag)) {
                // Rate limit low priority Dropbox entries
                mHandler.maybeDeferBroadcast(tag, time);
            } else {
                //发送ACTION_DROPBOX_ENTRY_ADDED广播
                //此处会调用 sendMessage(obtainMessage(MSG_SEND_BROADCAST, createIntent(tag, time)))
                mHandler.sendBroadcast(tag, time);
            }
        } .....
    }

   private static final int DEFAULT_AGE_SECONDS = 3 * 86400; //文件最长可存活时长为3天 
   //这两个最大文件数，通过AM.java的isLowRamDeviceStatic()控制，即debug.force_low_ram属性（默认false）
    private static final int DEFAULT_MAX_FILES = 1000; //最大dropbox文件个数为1000
    private static final int DEFAULT_MAX_FILES_LOWRAM = 300; //低rom时最大dropbox文件个数为300
    private static final int DEFAULT_QUOTA_KB = 5 * 1024; //分配dropbox空间的最大值5M
    private static final int DEFAULT_QUOTA_PERCENT = 10; //指dropbox目录最多可占用空间比例10% 
    private static final int DEFAULT_RESERVE_PERCENT = 10; //指dropbox不可使用的存储空间比例10% 
    private static final int QUOTA_RESCAN_MILLIS = 5000; //重新扫描retrim时长为5s

//将一个error错误的详细描述（例如crash、WTF、ANR）写入到drop box中
public void addErrorToDropBox(String eventType,
            ProcessRecord process, String processName, String activityShortComponentName,
            String parentShortComponentName, ProcessRecord parentProcess,
            String subject, final String report, final File dataFile,
            final ApplicationErrorReport.CrashInfo crashInfo) {
        //这绝对不能获取ActivityManagerService锁，
        //否则可以防止看门狗重置系统

        // 获取DropBoxManager服务对象
        if (ServiceManager.getService(Context.DROPBOX_SERVICE) == null) return;
        final DropBoxManager dbox = mContext.getSystemService(DropBoxManager.class);
        ......
        //头部信息，包含进程号、线程好、包名等
        final StringBuilder sb = new StringBuilder(1024);
        appendDropBoxProcessHeaders(process, processName, sb);
        //写入Activity名字、父进程、父Activity、对象、build时间、crash-tag标签等信息到sb对象中
        ......
        //创建一个子线程。在其中执行其余操作，以避免在I/O上阻塞调用程序
        //（在此之后，我们不应该访问AMS内部数据结构
        Thread worker = new Thread("Error dump: " + dropboxTag) {
            @Override
            public void run() {
                .....
                //调用DropBoxManager的addText，传入sb错误信息数据
                dbox.addText(dropboxTag, sb.toString());
            ......
            }
        }
        ......
            }

//frameworks/base/core/java/com/android/server/BootReceiver.java
public class BootReceiver extends BroadcastReceiver {
    private static final String TAG = "BootReceiver";
    ....
    @Override
    public void onReceive(final Context context, Intent intent) {
        // Log boot events in the background to avoid blocking the main thread with I/O
        new Thread() {
            @Override
            public void run() {
                try {
                    //调用logBootEvents输出日志信息
                    logBootEvents(context);
                } catch (Exception e) {
                    Slog.e(TAG, "Can't log boot events", e);
                }
                ....
            }
        }
    }
    .....
    private void logBootEvents(Context ctx) throws IOException {
        final DropBoxManager db = (DropBoxManager) ctx.getSystemService(Context.DROPBOX_SERVICE);
        final String headers = getBootHeadersToLogAndUpdate();
        final String bootReason = SystemProperties.get("ro.boot.bootreason", null);

        String recovery = RecoverySystem.handleAftermath(ctx);
        if (recovery != null && db != null) {
            //调用DropBoxManager的addText函数
            db.addText("SYSTEM_RECOVERY_LOG", headers + recovery);
        }
        ....
}

    private void logBootEvents(Context ctx) throws IOException {
        final DropBoxManager db = (DropBoxManager) ctx.getSystemService(Context.DROPBOX_SERVICE);
        ......
        if (SystemProperties.getLong("ro.runtime.firstboot", 0) == 0) {
            ......
        } else {
            if (db != null) db.addText("SYSTEM_RESTART", headers);
        }

kernel异常信息保存地：
panic
/proc/last_kmsg

oops
/sys/fs/pstore/console-ramoops
/sys/fs/pstore/console-ramoops-0

    private void logBootEvents(Context ctx) throws IOException {
        final DropBoxManager db = (DropBoxManager) ctx.getSystemService(Context.DROPBOX_SERVICE);
        ......
        if (SystemProperties.getLong("ro.runtime.firstboot", 0) == 0) {
            if (StorageManager.inCryptKeeperBounce()) {
                // Encrypted, first boot to get PIN/pattern/password so data is tmpfs
                // Don't set ro.runtime.firstboot so that we will do this again
                // when data is properly mounted
            } else {
                String now = Long.toString(System.currentTimeMillis());
                SystemProperties.set("ro.runtime.firstboot", now);
            }
            if (db != null) db.addText("SYSTEM_BOOT", headers);

            // Negative sizes mean to take the *tail* of the file (see FileUtils.readTextFile())
            //各个节点的日志信息
            addFileWithFootersToDropBox(db, timestamps, headers, lastKmsgFooter,
                    "/proc/last_kmsg", -LOG_SIZE, "SYSTEM_LAST_KMSG");
            addFileWithFootersToDropBox(db, timestamps, headers, lastKmsgFooter,
                    "/sys/fs/pstore/console-ramoops", -LOG_SIZE, "SYSTEM_LAST_KMSG");
            addFileWithFootersToDropBox(db, timestamps, headers, lastKmsgFooter,
                    "/sys/fs/pstore/console-ramoops-0", -LOG_SIZE, "SYSTEM_LAST_KMSG");
            addFileToDropBox(db, timestamps, headers, "/cache/recovery/log", -LOG_SIZE,
                    "SYSTEM_RECOVERY_LOG");
            addFileToDropBox(db, timestamps, headers, "/cache/recovery/last_kmsg",
                    -LOG_SIZE, "SYSTEM_RECOVERY_KMSG");
            addAuditErrorsToDropBox(db, timestamps, headers, -LOG_SIZE, "SYSTEM_AUDIT");
        } else {
            if (db != null) db.addText("SYSTEM_RESTART", headers);
        }

SYSTEM_RECOVERY_KMSG：recovery kerenl日志
SYSTEM_RECOVERY_LOG：recovery 升级或恢复出厂设置等等日志

//frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
public void handleApplicationStrictModeViolation(
        IBinder app,
        int penaltyMask,
        StrictMode.ViolationInfo info) {
    ···
    //需要满足触发dropbox的条件
    if ((penaltyMask & StrictMode.PENALTY_DROPBOX) != 0) {
        Integer stackFingerprint = info.hashCode();
        boolean logIt = true;
        ···
        if (logIt) {//执行dropbox业务
            logStrictModeViolationToDropBox(r, info);
        }
    }

    ···
}

private void logStrictModeViolationToDropBox(
        ProcessRecord process,
        StrictMode.ViolationInfo info) {
    if (info == null) {
        return;
    }
    //收集信息，tag：***_strictmode
    ···省略···
    
    //加入到dropbox
    IoThread.getHandler().post(() -> {
        dbox.addText(dropboxTag, res);
    });
} 

final void doLowMemReportIfNeededLocked(ProcessRecord dyingProc) {
    //如果不再有任何后台进程在运行，并且死亡的应用程序没有运行检测，那么告诉所有人我们现在的内存不足
    if (!mProcessList.haveBackgroundProcessLocked()) {
        ···
        //event事件的日志记录：EventLogTags.AM_LOW_MEMORY --> am_low_memory
        EventLog.writeEvent(EventLogTags.AM_LOW_MEMORY, mProcessList.getLruSizeLocked());
        ···
        if (doReport) {//如果报告，最后调入reportMemUsage
            Message msg = mHandler.obtainMessage(REPORT_MEM_USAGE_MSG, memInfos);
            mHandler.sendMessage(msg);
        }
        ···
    }
}

void reportMemUsage(ArrayList<ProcessMemInfo> memInfos) {
    ···
    addErrorToDropBox("lowmem", null, "system_server", null,
            null, null, tag.toString(), dropBuilder.toString(), null, null);
    ···
}

//frameworks/base/services/core/java/com/android/server/Watchdog.java
@Override
    public void run() {
            ......

            // 尝试将错误添加到下拉框中，但假设ActivityManager本身可能已死锁。
            //（发生了这种情况，导致此语句死锁，整个监视器无效）
            Thread dropboxThread = new Thread("watchdogWriteToDropbox") {
                    public void run() {
                        // If a watched thread hangs before init() is called, we don't have a
                        // valid mActivity. So we can't log the error to dropbox.
                        if (mActivity != null) {
                            mActivity.addErrorToDropBox(
                                    "watchdog", null, "system_server", null, null, null,
                                    subject, null, stack, null);
                        }
                        StatsLog.write(StatsLog.SYSTEM_SERVER_WATCHDOG_OCCURRED, subject);
                    }
                };
            dropboxThread.start();
            try {
                dropboxThread.join(2000);  // wait up to 2 seconds for it to return.
            } catch (InterruptedException ignored) {}
            ....
    }

//frameworks/base/services/core/java/com/android/server/net/NetworkStatsService.java
private static final String TAG_NETSTATS_ERROR = "netstats_error";

private class DropBoxNonMonotonicObserver implements NonMonotonicObserver<String> {
    @Override
    public void foundNonMonotonic(NetworkStats left, int leftIndex, NetworkStats right,
            int rightIndex, String cookie) {
        Log.w(TAG, "Found non-monotonic values; saving to dropbox");

        // record error for debugging
        final StringBuilder builder = new StringBuilder();
        builder.append("found non-monotonic " + cookie + " values at left[" + leftIndex
                + "] - right[" + rightIndex + "]\n");
        builder.append("left=").append(left).append('\n');
        builder.append("right=").append(right).append('\n');

        mContext.getSystemService(DropBoxManager.class).addText(TAG_NETSTATS_ERROR,
                builder.toString());
    }

    @Override
    public void foundNonMonotonic(
            NetworkStats stats, int statsIndex, String cookie) {
        Log.w(TAG, "Found non-monotonic values; saving to dropbox");

        final StringBuilder builder = new StringBuilder();
        builder.append("Found non-monotonic " + cookie + " values at [" + statsIndex + "]\n");
        builder.append("stats=").append(stats).append('\n');

        mContext.getSystemService(DropBoxManager.class).addText(TAG_NETSTATS_ERROR,
                builder.toString());
    }
}

//frameworks/base/services/core/java/com/android/server/net/NetworkStatsRecorder.java
private static final String TAG_NETSTATS_DUMP = "netstats_dump";

private void recoverFromWtf() {
    if (DUMP_BEFORE_DELETE) {
        ···
        mDropBox.addData(TAG_NETSTATS_DUMP, os.toByteArray(), 0);
    }
    ···
}

//frameworks/base/services/core/java/com/android/server/BatteryService.java
// TODO: Current code doesn't work since "--unplugged" flag in BSS was purposefully removed.
private void logBatteryStatsLocked() {
    ···
    DropBoxManager db = (DropBoxManager) mContext.getSystemService(Context.DROPBOX_SERVICE);
    ···
    try {
        ··· 
        // add dump file to drop box
        db.addFile("BATTERY_DISCHARGE_INFO", dumpFile, DropBoxManager.IS_TEXT);
    }
    ···
}

//frameworks/base/services/core/java/com/android/server/StorageManagerService.java
private static final String TAG_STORAGE_BENCHMARK = "storage_benchmark";
private static final String TAG_STORAGE_TRIM = "storage_trim";
    
public void benchmark(String volId, IVoldTaskListener listener) {
    ···
    mVold.benchmark(volId, new IVoldTaskListener.Stub() {
        ···
        final DropBoxManager dropBox = mContext.getSystemService(DropBoxManager.class);
        dropBox.addText(TAG_STORAGE_BENCHMARK, scrubPath(path)
                    + " " + ident + " " + create + " " + run + " " + destroy);
    ···
    });
}

public void fstrim(int flags, IVoldTaskListener listener) {
    ···
    mVold.fstrim(flags, new IVoldTaskListener.Stub() {
        @Override
        public void onStatus(int status, PersistableBundle extras) {
            ···
            final DropBoxManager dropBox = mContext.getSystemService(DropBoxManager.class);
                dropBox.addText(TAG_STORAGE_TRIM, scrubPath(path) + " " + bytes + " " + time);
            ···
            }
            ···
        });
    ···
}

//frameworks/base/services/core/java/com/android/server/net/watchlist/WatchlistLoggingHandler.java
private static final String DROPBOX_TAG = "network_watchlist_report";

private void tryAggregateRecords(long lastRecordTime) {
    try {
        ···
        if (mDropBoxManager != null && mDropBoxManager.isTagEnabled(DROPBOX_TAG)) {
            ···
            if (encodedResult != null) {
                addEncodedReportToDropBox(encodedResult);
            }
        ......
    }
}

private void addEncodedReportToDropBox(byte[] encodedReport) {
    mDropBoxManager.addData(DROPBOX_TAG, encodedReport, 0);
}

//frameworks/base/cmds/incidentd/src/Broadcaster.cpp
status_t Broadcaster::send_to_dropbox(const sp<ReportFile>& file,
        const IncidentReportArgs& args) {
    status_t err;

    sp<DropBoxManager> dropbox = new DropBoxManager();
    if (dropbox == nullptr) {
        ALOGW("Can't reach dropbox now, so we won't be able to write the incident report to there");
        return NO_ERROR;
    }
    .....
    // Takes ownership of readFd.
    Status status = dropbox->addFile(String16("incident"), readFd, 0);
    ......
    return NO_ERROR;
}

//system/security/keystore/operation_proto_handler.cpp 
void OperationProtoHandler::uploadOpAsProto(Operation& op, bool wasOpSuccessful) {
    ......
android::sp<android::os::DropBoxManager> dropbox(new android::os::DropBoxManager);
size_t size = opConfigEvents.ByteSize();
auto data = std::make_unique<uint8_t[]>(size);
opConfigEvents.SerializeWithCachedSizesToArray(data.get());
dropbox->addData(android::String16("keymaster"), data.get(), size, 0);
.....
}

//system/security/keystore/key_proto_handler.cpp
void uploadKeyCharacteristicsAsProto(const hidl_vec<KeyParameter>& keyParams, bool wasCreationSuccessful) {
    .....
android::sp<android::os::DropBoxManager> dropbox(new android::os::DropBoxManager());
keyConfig.set_was_creation_successful(wasCreationSuccessful);
size_t size = keyConfig.ByteSize();
auto data = std::make_unique<uint8_t[]>(size);
keyConfig.SerializeWithCachedSizesToArray(data.get());
dropbox->addData(android::String16("keymaster"), data.get(), size, 0);
....
}