MediaScanner.cpp revision 1a65546a55d019335655464ad895361ba9f89252 
1/*
2 * Copyright (C) 2009 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17//#define LOG_NDEBUG 0
18#define LOG_TAG "MediaScanner"
19#include <utils/Log.h>
20
21#include <media/mediascanner.h>
22
23#include <sys/stat.h>
24#include <dirent.h>
25
26namespace android {
27
28MediaScanner::MediaScanner()
29    : mLocale(NULL) {
30}
31
32MediaScanner::~MediaScanner() {
33    setLocale(NULL);
34}
35
36void MediaScanner::setLocale(const char *locale) {
37    if (mLocale) {
38        free(mLocale);
39        mLocale = NULL;
40    }
41    if (locale) {
42        mLocale = strdup(locale);
43    }
44}
45
46const char *MediaScanner::locale() const {
47    return mLocale;
48}
49
50status_t MediaScanner::processDirectory(
51        const char *path, MediaScannerClient &client,
52        ExceptionCheck exceptionCheck, void *exceptionEnv) {
53    int pathLength = strlen(path);
54    if (pathLength >= PATH_MAX) {
55        return UNKNOWN_ERROR;
56    }
57    char* pathBuffer = (char *)malloc(PATH_MAX + 1);
58    if (!pathBuffer) {
59        return UNKNOWN_ERROR;
60    }
61
62    int pathRemaining = PATH_MAX - pathLength;
63    strcpy(pathBuffer, path);
64    if (pathLength > 0 && pathBuffer[pathLength - 1] != '/') {
65        pathBuffer[pathLength] = '/';
66        pathBuffer[pathLength + 1] = 0;
67        --pathRemaining;
68    }
69
70    client.setLocale(locale());
71
72    status_t result =
73        doProcessDirectory(pathBuffer, pathRemaining, client, false, exceptionCheck, exceptionEnv);
74
75    free(pathBuffer);
76
77    return result;
78}
79
80status_t MediaScanner::doProcessDirectory(
81        char *path, int pathRemaining, MediaScannerClient &client,
82        bool noMedia, ExceptionCheck exceptionCheck, void *exceptionEnv) {
83    // place to copy file or directory name
84    char* fileSpot = path + strlen(path);
85    struct dirent* entry;
86    struct stat statbuf;
87
88    // Treat all files as non-media in directories that contain a  ".nomedia" file
89    if (pathRemaining >= 8 /* strlen(".nomedia") */ ) {
90        strcpy(fileSpot, ".nomedia");
91        if (access(path, F_OK) == 0) {
92            LOGD("found .nomedia, setting noMedia flag\n");
93            noMedia = true;
94        }
95
96        // restore path
97        fileSpot[0] = 0;
98    }
99
100    DIR* dir = opendir(path);
101    if (!dir) {
102        LOGD("opendir %s failed, errno: %d", path, errno);
103        return UNKNOWN_ERROR;
104    }
105
106    while ((entry = readdir(dir))) {
107        const char* name = entry->d_name;
108
109        // ignore "." and ".."
110        if (name[0] == '.' && (name[1] == 0 || (name[1] == '.' && name[2] == 0))) {
111            continue;
112        }
113
114        int nameLength = strlen(name);
115        if (nameLength + 1 > pathRemaining) {
116            // path too long!
117            continue;
118        }
119        strcpy(fileSpot, name);
120
121        int type = entry->d_type;
122        if (type == DT_UNKNOWN) {
123            // If the type is unknown, stat() the file instead.
124            // This is sometimes necessary when accessing NFS mounted filesystems, but
125            // could be needed in other cases well.
126            if (stat(path, &statbuf) == 0) {
127                if (S_ISREG(statbuf.st_mode)) {
128                    type = DT_REG;
129                } else if (S_ISDIR(statbuf.st_mode)) {
130                    type = DT_DIR;
131                }
132            } else {
133                LOGD("stat() failed for %s: %s", path, strerror(errno) );
134            }
135        }
136        if (type == DT_REG || type == DT_DIR) {
137            if (type == DT_DIR) {
138                bool childNoMedia = noMedia;
139                // set noMedia flag on directories with a name that starts with '.'
140                // for example, the Mac ".Trashes" directory
141                if (name[0] == '.')
142                    childNoMedia = true;
143
144                // report the directory to the client
145                if (stat(path, &statbuf) == 0) {
146                    client.scanFile(path, statbuf.st_mtime, 0, true, childNoMedia);
147                }
148
149                // and now process its contents
150                strcat(fileSpot, "/");
151                int err = doProcessDirectory(path, pathRemaining - nameLength - 1, client,
152                        childNoMedia, exceptionCheck, exceptionEnv);
153                if (err) {
154                    // pass exceptions up - ignore other errors
155                    if (exceptionCheck && exceptionCheck(exceptionEnv)) goto failure;
156                    LOGE("Error processing '%s' - skipping\n", path);
157                    continue;
158                }
159            } else {
160                stat(path, &statbuf);
161                client.scanFile(path, statbuf.st_mtime, statbuf.st_size, false, noMedia);
162                if (exceptionCheck && exceptionCheck(exceptionEnv)) goto failure;
163            }
164        }
165    }
166
167    closedir(dir);
168    return OK;
169failure:
170    closedir(dir);
171    return -1;
172}
173
174}  // namespace android
175