static MediaScanner *getNativeScanner_l(JNIEnv* env, jobject thiz) {
    return (MediaScanner *) env->GetLongField(thiz, fields.context);
}

static void
android_media_MediaScanner_native_setup(JNIEnv *env, jobject thiz)
{
    ALOGV("native_setup");
    MediaScanner *mp = new StagefrightMediaScanner;
    //..............
    env->SetLongField(thiz, fields.context, (jlong)mp);
}

status_t StagefrightMetadataRetriever::setDataSource(int fd, int64_t offset, int64_t length) {
    fd = dup(fd);
    ALOGV("setDataSource(%d, %" PRId64 ", %" PRId64 ")", fd, offset, length);
    clearMetadata();
    mSource = new FileSource(fd, offset, length);
    status_t err;
    //检查是否打开文件成功
    if ((err = mSource->initCheck()) != OK) {
        mSource.clear();
        return err;
    }
    //将FileSource传入后根据FileSource的信息创建出合适的MediaExtractor
    mExtractor = MediaExtractor::Create(mSource);
    if (mExtractor == NULL) {
        mSource.clear();
        return UNKNOWN_ERROR;
    }
    return OK;
}

StagefrightMetadataRetriever::StagefrightMetadataRetriever()
    : mParsedMetaData(false),
      mAlbumArt(NULL) {
    //注册默认的音频格式嗅探器
    DataSource::RegisterDefaultSniffers();
    CHECK_EQ(mClient.connect(), (status_t)OK);
}

//static
void DataSource::RegisterDefaultSniffers() {
    Mutex::Autolock autoLock(gSnifferMutex);
    if (gSniffersRegistered) {
        return;
    }
    RegisterSniffer_l(SniffMPEG4);
    RegisterSniffer_l(SniffMatroska);
    RegisterSniffer_l(SniffOgg);
    RegisterSniffer_l(SniffWAV);
    RegisterSniffer_l(SniffFLAC);
    RegisterSniffer_l(SniffAMR);
    RegisterSniffer_l(SniffMPEG2TS);
    RegisterSniffer_l(SniffMP3);
    RegisterSniffer_l(SniffAAC);
    RegisterSniffer_l(SniffMPEG2PS);
    RegisterSniffer_l(SniffWVM);
    RegisterSniffer_l(SniffMidi);

    char value[PROPERTY_VALUE_MAX];
    if (property_get("drm.service.enabled", value, NULL)
            && (!strcmp(value, "1") || !strcasecmp(value, "true"))) {
        RegisterSniffer_l(SniffDRM);
    }
    gSniffersRegistered = true;
}

sp<MetaData> MP3Extractor::getMetaData() {
    sp<MetaData> meta = new MetaData;

    if (mInitCheck != OK) {
        return meta;
    }
    //设置mimetype
    meta->setCString(kKeyMIMEType, "audio/mpeg");
    //创建id3
    ID3 id3(mDataSource);

    if (!id3.isValid()) {
        return meta;
    }

    struct Map {
        int key;
        const char *tag1;
        const char *tag2;
    };
    static const Map kMap[] = {
        { kKeyAlbum, "TALB", "TAL" },
        { kKeyArtist, "TPE1", "TP1" },
        { kKeyAlbumArtist, "TPE2", "TP2" },
        { kKeyComposer, "TCOM", "TCM" },
        { kKeyGenre, "TCON", "TCO" },
        { kKeyTitle, "TIT2", "TT2" },
        { kKeyYear, "TYE", "TYER" },
        { kKeyAuthor, "TXT", "TEXT" },
        { kKeyCDTrackNumber, "TRK", "TRCK" },
        { kKeyDiscNumber, "TPA", "TPOS" },
        { kKeyCompilation, "TCP", "TCMP" },
    };
    static const size_t kNumMapEntries = sizeof(kMap) / sizeof(kMap[0]);
    //获取上面提到的TAG
    for (size_t i = 0; i < kNumMapEntries; ++i) {
        ID3::Iterator *it = new ID3::Iterator(id3, kMap[i].tag1);
        if (it->done()) {
            delete it;
            it = new ID3::Iterator(id3, kMap[i].tag2);
        }
        if (it->done()) {
            delete it;
            continue;
        }
        String8 s;
        it->getString(&s);
        delete it;
        meta->setCString(kMap[i].key, s);
    }

    size_t dataSize;
    String8 mime;
    //获取专辑封面
    const void *data = id3.getAlbumArt(&dataSize, &mime);
    if (data) {
        meta->setData(kKeyAlbumArt, MetaData::TYPE_NONE, data, dataSize);
        meta->setCString(kKeyAlbumArtMIME, mime.string());
    }
    return meta;
}

ID3::ID3(const sp<DataSource> &source, bool ignoreV1, off64_t offset)
    : mIsValid(false),
      mData(NULL),
      mSize(0),
      mFirstFrameOffset(0),
      mVersion(ID3_UNKNOWN),
      mRawSize(0) {
    //解析ID3V2Tab内容
    mIsValid = parseV2(source, offset);

    if (!mIsValid && !ignoreV1) {
        //解析ID3V1 TAB 内容
        mIsValid = parseV1(source);
    }
}

ID3::Iterator::Iterator(const ID3 &parent, const char *id)
    : mParent(parent),
      mID(NULL),
      mOffset(mParent.mFirstFrameOffset),
      mFrameData(NULL),
      mFrameSize(0) {
    if (id) {
        mID = strdup(id);
    }
    //找到帧对应的位置
    findFrame();
}

status_t MediaScannerClient::addStringTag(const char* name, const char* value)
{
    handleStringTag(name, value);
    return OK;
}

public void handleStringTag(String name, String value) {
    if (name.equalsIgnoreCase("title") || name.startsWith("title;")) {
        // Don't trim() here, to preserve the special \001 character
        // used to force sorting. The media provider will trim() before
        // inserting the title in to the database.
        mTitle = value;
    } else if (name.equalsIgnoreCase("artist") || name.startsWith("artist;")) {
        mArtist = value.trim();
    } else if (name.equalsIgnoreCase("albumartist") || name.startsWith("albumartist;")
            || name.equalsIgnoreCase("band") || name.startsWith("band;")) {
        mAlbumArtist = value.trim();
    } else if (name.equalsIgnoreCase("album") || name.startsWith("album;")) {
        mAlbum = value.trim();
    } else if (name.equalsIgnoreCase("composer") || name.startsWith("composer;")) {
        mComposer = value.trim();
    } else if (mProcessGenres &&
            (name.equalsIgnoreCase("genre") || name.startsWith("genre;"))) {
        mGenre = getGenreName(value);
    } else if (name.equalsIgnoreCase("year") || name.startsWith("year;")) {
        mYear = parseSubstring(value, 0, 0);
    } else if (name.equalsIgnoreCase("tracknumber") || name.startsWith("tracknumber;")) {
        // track number might be of the form "2/12"
        // we just read the number before the slash
        int num = parseSubstring(value, 0, 0);
        mTrack = (mTrack / 1000) * 1000 + num;
    } else if (name.equalsIgnoreCase("discnumber") ||
            name.equals("set") || name.startsWith("set;")) {
        // set number might be of the form "1/3"
        // we just read the number before the slash
        int num = parseSubstring(value, 0, 0);
        mTrack = (num * 1000) + (mTrack % 1000);
    } else if (name.equalsIgnoreCase("duration")) {
        mDuration = parseSubstring(value, 0, 0);
    } else if (name.equalsIgnoreCase("writer") || name.startsWith("writer;")) {
        mWriter = value.trim();
    } else if (name.equalsIgnoreCase("compilation")) {
        mCompilation = parseSubstring(value, 0, 0);
    } else if (name.equalsIgnoreCase("isdrm")) {
        mIsDrm = (parseSubstring(value, 0, 0) == 1);
    } else if (name.equalsIgnoreCase("width")) {
        mWidth = parseSubstring(value, 0, 0);
    } else if (name.equalsIgnoreCase("height")) {
        mHeight = parseSubstring(value, 0, 0);
    } else {
        //Log.v(TAG, "unknown tag: " + name + " (" + mProcessGenres + ")");
    }
}

virtual status_t handleStringTag(const char* name, const char* value)
{
    ALOGV("MediaScanner handleStringTag: name(%s) and value(%s)", name, value);
    jstring nameStr, valueStr;
    if ((nameStr = mEnv->NewStringUTF(name)) == NULL) {
        mEnv->ExceptionClear();
        return NO_MEMORY;
    }
    char *cleaned = NULL;
    //如果不是正常的UTF-8则将其置为？
    if (!isValidUtf8(value)) {
        cleaned = strdup(value);
        char *chp = cleaned;
        char ch;
        while ((ch = *chp)) {
            if (ch & 0x80) {
                *chp = '?';
            }
            chp++;
        }
        value = cleaned;
    }
    valueStr = mEnv->NewStringUTF(value);
    free(cleaned);
    if (valueStr == NULL) {
        mEnv->DeleteLocalRef(nameStr);
        mEnv->ExceptionClear();
        return NO_MEMORY;
    }
    //调用JAVA层的handleStringTag方法。
    mEnv->CallVoidMethod(mClient, mHandleStringTagMethodID, nameStr, valueStr);
    mEnv->DeleteLocalRef(nameStr);
    mEnv->DeleteLocalRef(valueStr);
    return checkAndClearExceptionFromCallback(mEnv, "handleStringTag");
}

最后还是上个图吧，虽然流程简单但是还是很杂的，容易乱：
![](/Android-源码分析之MediaScanner-2.md/1.png)

public void onReceive(Context context, Intent intent) {
    final String action = intent.getAction();
    final Uri uri = intent.getData();
    //收到开机广播后扫描
    if (Intent.ACTION_BOOT_COMPLETED.equals(action)) {
        // Scan both internal and external storage
         //扫描内部存储器中/system/media里面的内容，存放的是铃声等多媒体文件
        scan(context, MediaProvider.INTERNAL_VOLUME);
        //扫描手机的外部存储实际扫描的是/mnt/sdcard/
        scan(context, MediaProvider.EXTERNAL_VOLUME);

    } else {
        if (uri.getScheme().equals("file")) {
            // handle intents related to external storage
            String path = uri.getPath();
            String externalStoragePath = Environment.getExternalStorageDirectory().getPath();
            String legacyPath = Environment.getLegacyExternalStorageDirectory().getPath();
            try {
                path = new File(path).getCanonicalPath();
            } catch (IOException e) {
                Log.e(TAG, "couldn't canonicalize " + path);
                return;
            }
            if (path.startsWith(legacyPath)) {
                path = externalStoragePath + path.substring(legacyPath.length());
            }

            Log.d(TAG, "action: " + action + " path: " + path);
            //收到外部存储器加载完成广播的扫描
            if (Intent.ACTION_MEDIA_MOUNTED.equals(action)) {
                // scan whenever any volume is mounted
                scan(context, MediaProvider.EXTERNAL_VOLUME);
                //如果请求的是扫描路径，并且要扫描的属于外部存储路径则开始扫描
            } else if (Intent.ACTION_MEDIA_SCANNER_SCAN_FILE.equals(action) &&
                    path != null && path.startsWith(externalStoragePath + "/")) {
                scanFile(context, path);
            }
        }
    }
}

public void run()
{
    // reduce priority below other background threads to avoid interfering
    // with other services at boot time.
    Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND +Process.THREAD_PRIORITY_LESS_FAVORABLE);
    Looper.prepare();

    mServiceLooper = Looper.myLooper();
    mServiceHandler = new ServiceHandler();
    Looper.loop();
}

private final class ServiceHandler extends Handler
{
    @Override
    public void handleMessage(Message msg)
    {
        Bundle arguments = (Bundle) msg.obj;
        String filePath = arguments.getString("filepath");
        
        try {
            //这是扫描单个文件的情况
            if (filePath != null) {
                IBinder binder = arguments.getIBinder("listener");
                IMediaScannerListener listener = 
                        (binder == null ? null : IMediaScannerListener.Stub.asInterface(binder));
                Uri uri = null;
                try {
                    //调用scanFile方法
                    uri = scanFile(filePath, arguments.getString("mimetype"));
                } catch (Exception e) {
                    Log.e(TAG, "Exception scanning file", e);
                }
                if (listener != null) {
                    listener.scanCompleted(filePath, uri);
                }
            //这是扫描一个目录的情况
            } else {
                String volume = arguments.getString("volume");
                String[] directories = null;
                if (MediaProvider.INTERNAL_VOLUME.equals(volume)) {
                    //这是扫描内部存储的情况
                    // scan internal media storage
                    directories = new String[] {
                            Environment.getRootDirectory() + "/media",
                            Environment.getOemDirectory() + "/media",
                    };
                }
                else if (MediaProvider.EXTERNAL_VOLUME.equals(volume)) {
                    // scan external storage volumes
                    //这是扫描外部存储的情况
                    directories = mExternalStoragePaths;
                }

                if (directories != null) {
                    if (false) Log.d(TAG, "start scanning volume " + volume + ": "
                            + Arrays.toString(directories));
                    //调用scan方法
                    scan(directories, volume);
                    if (false) Log.d(TAG, "done scanning volume " + volume);
                }
            }
        } catch (Exception e) {
            Log.e(TAG, "Exception in handleMessage", e);
        }
        //扫描结束后退出服务
        stopSelf(msg.arg1);
    }
};

private void scan(String[] directories, String volumeName) {
    Uri uri = Uri.parse("file://" + directories[0]);
    // don't sleep while scanning
    //获取唤醒锁，避免在扫描的时候手机发生睡眠
    mWakeLock.acquire();

    try {
        ContentValues values = new ContentValues();
        values.put(MediaStore.MEDIA_SCANNER_VOLUME, volumeName);
        Uri scanUri = getContentResolver().insert(MediaStore.getMediaScannerUri(), values);
            
        //发送ACTION_MEDIA_SCANNER_STARTED广播通知系统其他部件扫描即将开始
        sendBroadcast(new Intent(Intent.ACTION_MEDIA_SCANNER_STARTED, uri));

        try {
            if (volumeName.equals(MediaProvider.EXTERNAL_VOLUME)) {
                openDatabase(volumeName);
            }
            //创建MediaScanner开始扫描
            MediaScanner scanner = createMediaScanner();
            scanner.scanDirectories(directories, volumeName);
        } catch (Exception e) {
            Log.e(TAG, "exception in MediaScanner.scan()", e);
        }

        getContentResolver().delete(scanUri, null, null);

    } finally {
        //通知其他部件扫描结束
        sendBroadcast(new Intent(Intent.ACTION_MEDIA_SCANNER_FINISHED, uri));
        //释放唤醒锁
        mWakeLock.release();
    }
}

static {
    System.loadLibrary("media_jni");
    native_init();
}

static void
android_media_MediaScanner_native_setup(JNIEnv *env, jobject thiz)
{
    MediaScanner *mp = new StagefrightMediaScanner;
    if (mp == NULL) {
        jniThrowException(env, kRunTimeException, "Out of memory");
        return;
    }
    env->SetLongField(thiz, fields.context, (jlong)mp);
}

public void scanDirectories(String[] directories, String volumeName) {
    
    //.......
    //1.扫描前预处理
    initialize(volumeName);
    //2. 预扫描
    prescan(null, true);
    //.......
    if (ENABLE_BULK_INSERTS) {
        // create MediaInserter for bulk inserts
        mMediaInserter = new MediaInserter(mMediaProvider, mPackageName, 500);
    }

    for (int i = 0; i < directories.length; i++) {
        //3.扫描某个目录
        processDirectory(directories[i], mClient);
    }

    if (ENABLE_BULK_INSERTS) {
        // flush remaining inserts
        mMediaInserter.flushAll();
        mMediaInserter = null;
    }
    //4. 扫描后处理
    postscan(directories);
    //.......
}

private void prescan(String filePath, boolean prescanFiles) throws RemoteException {
    Cursor c = null;
    String where = null;
    String[] selectionArgs = null;
    //建立mPlayLists
    if (mPlayLists == null) {
        mPlayLists = new ArrayList<FileEntry>();
    } else {
        mPlayLists.clear();
    }
    //通过上述处理mPlayLists将会被清空，
    if (filePath != null) {
        // query for only one file
        where = MediaStore.Files.FileColumns._ID + ">?" +" AND " + Files.FileColumns.DATA + "=?";
        selectionArgs = new String[] { "", filePath };
    } else {
        where = MediaStore.Files.FileColumns._ID + ">?";
        selectionArgs = new String[] { "" };
    }

    // Tell the provider to not delete the file.
    // If the file is truly gone the delete is unnecessary, and we want to avoid
    // accidentally deleting files that are really there (this may happen if the
    // filesystem is mounted and unmounted while the scanner is running).
    //在这里告诉provider不要删除那些通过扫描发现不存在的文件，
    为的是避免在扫描的时候文件系统卸载了，但是在以后的时候又挂载上了。
    Uri.Builder builder = mFilesUri.buildUpon();
    builder.appendQueryParameter(MediaStore.PARAM_DELETE_DATA, "false");
    MediaBulkDeleter deleter = new MediaBulkDeleter(mMediaProvider, mPackageName,builder.build());

    // Build the list of files from the content provider
    try {
        if (prescanFiles) {
            // First read existing files from the files table.
            // Because we'll be deleting entries for missing files as we go,
            // we need to query the database in small batches, to avoid problems
            // with CursorWindow positioning.
            long lastId = Long.MIN_VALUE;
            Uri limitUri = mFilesUri.buildUpon().appendQueryParameter("limit", "1000").build();
            mWasEmptyPriorToScan = true;
            while (true) {
                selectionArgs[0] = "" + lastId;
                if (c != null) {
                    c.close();
                    c = null;
                }
                c = mMediaProvider.query(mPackageName, limitUri, FILES_PRESCAN_PROJECTION,where, selectionArgs, MediaStore.Files.FileColumns._ID, null);
                if (c == null) {
                    break;
                }
                int num = c.getCount();
                if (num == 0) {
                    //如果为0表示已经查询完全部文件信息,退出循环
                    break;
                }
                mWasEmptyPriorToScan = false;
                //开始获取这一批查询到的要扫描的路径等信息
                while (c.moveToNext()) {
                    long rowId = c.getLong(FILES_PRESCAN_ID_COLUMN_INDEX);
                    String path = c.getString(FILES_PRESCAN_PATH_COLUMN_INDEX);
                    int format = c.getInt(FILES_PRESCAN_FORMAT_COLUMN_INDEX);
                    long lastModified = c.getLong(FILES_PRESCAN_DATE_MODIFIED_COLUMN_INDEX);
                    lastId = rowId;
                    // Only consider entries with absolute path names.
                    // This allows storing URIs in the database without the
                    // media scanner removing them.
                    if (path != null && path.startsWith("/")) {
                        boolean exists = false;
                        try {
                            //查看数据库中对应项的本地文件是否存在
                            exists = Os.access(path, android.system.OsConstants.F_OK);
                        } catch (ErrnoException e1) {
                        }
                        if (!exists && !MtpConstants.isAbstractObject(format)) {
                            // do not delete missing playlists, since they may have been
                            // modified by the user.
                            // The user can delete them in the media player instead.
                            // instead, clear the path and lastModified fields in the row
                            MediaFile.MediaFileType mediaFileType = MediaFile.getFileType(path);
                            int fileType = (mediaFileType == null ? 0 : mediaFileType.fileType);
                            
                            //如果当前记录在数据库中存在，在本地中文件并不存在，
                            //并且丢失的文件类型不是播放列表则将记录从数据库中删除
                            //如果是播放列表类型则不删除
                            if (!MediaFile.isPlayListFileType(fileType)) {
                                deleter.delete(rowId);
                                if (path.toLowerCase(Locale.US).endsWith("/.nomedia")) {
                                    deleter.flush();
                                    String parent = new File(path).getParent();
                                    mMediaProvider.call(mPackageName, MediaStore.UNHIDE_CALL,parent, null);
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    finally {
        if (c != null) {
            c.close();
        }
        deleter.flush();
    }
    // compute original size of images
    mOriginalCount = 0;
    c = mMediaProvider.query(mPackageName, mImagesUri, ID_PROJECTION, null, null, null, null);
    if (c != null) {
        mOriginalCount = c.getCount();
        c.close();
    }
}

MediaScanResult MediaScanner::doProcessDirectoryEntry(char *path, int pathRemaining, MediaScannerClient &client, bool noMedia,struct dirent* entry, char* fileSpot) {
    struct stat statbuf;
    const char* name = entry->d_name;
    if (type == DT_DIR) {
        // report the directory to the client
        //如果是目录类型
        if (stat(path, &statbuf) == 0) {
            //调用client.scanFile扫描目录：这里的isDirectory = true
            status_t status = client.scanFile(path, statbuf.st_mtime, 0,true /*isDirectory*/, childNoMedia);
            if (status) {
                return MEDIA_SCAN_RESULT_ERROR;
            }
        }
        // and now process its contents
        //在这个地方开始扫描该目录的子文件
        strcat(fileSpot, "/");
        MediaScanResult result = doProcessDirectory(path, pathRemaining - nameLength - 1, client, childNoMedia);
        if (result == MEDIA_SCAN_RESULT_ERROR) {
            return MEDIA_SCAN_RESULT_ERROR;
        }
    } else if (type == DT_REG) {
        //如果是普通文件  这里的isDirectory = false
        stat(path, &statbuf);
        status_t status = client.scanFile(path, statbuf.st_mtime, statbuf.st_size,false /*isDirectory*/, noMedia);
        if (status) {
            return MEDIA_SCAN_RESULT_ERROR;
        }
    }
    return MEDIA_SCAN_RESULT_OK;
}

private void processPlayList(FileEntry entry, Cursor fileList) throws RemoteException {
    
    String path = entry.mPath;
    ContentValues values = new ContentValues();
    int lastSlash = path.lastIndexOf('/');
    if (lastSlash < 0) throw new IllegalArgumentException("bad path " + path);
    Uri uri, membersUri;
    //从FileEnty中获取rowId
    long rowId = entry.mRowId;
    // 确保有一个播放列表名字，首先查看MediaStore.Audio.Playlists.NAME
    // 再查看MediaStore.MediaColumns.TITLE 如果还是为空则获取最后的.后面的字符
    String name = values.getAsString(MediaStore.Audio.Playlists.NAME);
    if (name == null) {
        name = values.getAsString(MediaStore.MediaColumns.TITLE);
        if (name == null) {
            // 从文件中获取播放列表名字
            int lastDot = path.lastIndexOf('.');
            name = (lastDot < 0 ? path.substring(lastSlash + 1): 
                   path.substring(lastSlash + 1, lastDot));
        }
    }
    //将播放列表的名字和修改时间添加到数据库中
    values.put(MediaStore.Audio.Playlists.NAME, name);
    values.put(MediaStore.Audio.Playlists.DATE_MODIFIED, entry.mLastModified);
    if (rowId == 0) {
        //如果不存在的话插入新的播放列表信息
        values.put(MediaStore.Audio.Playlists.DATA, path);
        //这时候value包含NAME  DATA  DATE_MODIFIED
        uri = mMediaProvider.insert(mPackageName, mPlaylistsUri, values);
        rowId = ContentUris.parseId(uri);
        //获得插入的行id 
        //获得播放列表成员的Uri
        membersUri = Uri.withAppendedPath(uri, Playlists.Members.CONTENT_DIRECTORY);
    } else {
        //如果存在的话就更新并且删除原来的member Uri
        uri = ContentUris.withAppendedId(mPlaylistsUri, rowId);
        mMediaProvider.update(mPackageName, uri, values, null, null);
        membersUri = Uri.withAppendedPath(uri, Playlists.Members.CONTENT_DIRECTORY);
        mMediaProvider.delete(mPackageName, membersUri, null, null);
    }
    //获取播放列表的目录
    String playListDirectory = path.substring(0, lastSlash + 1);
    //获取播放列表的文件类型
    MediaFile.MediaFileType mediaFileType = MediaFile.getFileType(path);
    int fileType = (mediaFileType == null ? 0 : mediaFileType.fileType);
    //根据不同的文件类型调用不同的方法调用不同的方法处理
    if (fileType == MediaFile.FILE_TYPE_M3U) {
        processM3uPlayList(path, playListDirectory, membersUri, values, fileList);
    } else if (fileType == MediaFile.FILE_TYPE_PLS) {
        processPlsPlayList(path, playListDirectory, membersUri, values, fileList);
    } else if (fileType == MediaFile.FILE_TYPE_WPL) {
        processWplPlayList(path, playListDirectory, membersUri, values, fileList);
    }
}