static void
enumerate_children_ready_cb (GObject *source,
GAsyncResult *res,
gpointer user_data)
{
GFile *location = G_FILE (source);
GFileEnumerator *enumerator;
GError *error = NULL;
BijiNoteBook *self;
enumerator = g_file_enumerate_children_finish (location,
res, &error);
if (error != NULL)
{
load_location_error (location, error);
return;
}
self = user_data;
// enumerate all files
g_file_enumerator_next_files_async (enumerator, G_MAXINT,
G_PRIORITY_DEFAULT,
self->priv->load_cancellable,
enumerate_next_files_ready_cb,
self);
}
static void
dir_enum_async_ready (GObject *source,
GAsyncResult *res,
gpointer user_data)
{
BgPicturesSourcePrivate *priv;
GFileEnumerator *enumerator;
GError *err = NULL;
enumerator = g_file_enumerate_children_finish (G_FILE (source), res, &err);
if (err)
{
if (!g_error_matches (err, G_IO_ERROR, G_IO_ERROR_CANCELLED))
g_warning ("Could not fill pictures source: %s", err->message);
g_error_free (err);
return;
}
priv = BG_PICTURES_SOURCE (user_data)->priv;
/* get the files */
g_file_enumerator_next_files_async (enumerator,
G_MAXINT,
G_PRIORITY_LOW,
priv->cancellable,
file_info_async_ready,
user_data);
g_object_unref (enumerator);
}
static void
delete_batch (GObject *source,
GAsyncResult *res,
gpointer user_data)
{
GFileEnumerator *enumerator = G_FILE_ENUMERATOR (source);
DeleteData *data = user_data;
GList *files, *f;
GFile *child_file;
DeleteData *child;
GFileInfo *info;
GError *error = NULL;
files = g_file_enumerator_next_files_finish (enumerator, res, &error);
g_debug ("GsdHousekeeping: purging %d children of %s", g_list_length (files), data->name);
if (files) {
for (f = files; f; f = f->next) {
if (g_cancellable_is_cancelled (data->cancellable))
break;
info = f->data;
child_file = g_file_get_child (data->file, g_file_info_get_name (info));
child = delete_data_new (child_file,
data->cancellable,
data->old,
data->dry_run,
data->trash,
data->depth + 1);
delete_recursively_by_age (child);
delete_data_unref (child);
g_object_unref (child_file);
}
g_list_free_full (files, g_object_unref);
if (!g_cancellable_is_cancelled (data->cancellable)) {
g_file_enumerator_next_files_async (enumerator, 20,
0,
data->cancellable,
delete_batch,
data);
return;
}
}
g_file_enumerator_close (enumerator, data->cancellable, NULL);
g_object_unref (enumerator);
if (data->depth > 0 && !g_cancellable_is_cancelled (data->cancellable)) {
if ((data->trash && data->depth > 1) ||
should_purge_file (data->file, data->cancellable, data->old)) {
g_debug ("GsdHousekeeping: purging %s\n", data->name);
if (!data->dry_run) {
g_file_delete (data->file, data->cancellable, NULL);
}
}
}
delete_data_unref (data);
}
static void
plugin_manager_next_files_ready (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
GigglePluginManager *manager = user_data;
GigglePluginManagerPriv *priv = GET_PRIV (manager);
GFileEnumerator *children = G_FILE_ENUMERATOR (object);
GError *error = NULL;
GList *files, *l;
files = g_file_enumerator_next_files_finish (children,
result, &error);
if (error) {
g_warning ("%s: %s", G_STRFUNC, error->message);
g_clear_error (&error);
}
for (l = files; l; l = g_list_delete_link (l, l)) {
const char *name = g_file_info_get_name (l->data);
char *filename;
GigglePlugin *plugin;
GFile *file;
if (g_str_has_suffix (name, ".xml")) {
file = g_file_get_child (priv->plugin_dir, name);
filename = g_file_get_path (file);
plugin = giggle_plugin_new_from_file (filename, &error);
g_object_unref (file);
g_free (filename);
if (plugin) {
giggle_plugin_set_manager (plugin, manager);
priv->plugins = g_list_prepend (priv->plugins, plugin);
g_signal_emit (manager, signals[PLUGIN_ADDED], 0, plugin);
} else {
g_warning ("%s: %s", G_STRFUNC, error->message);
g_clear_error (&error);
}
}
g_object_unref (l->data);
}
if (files) {
g_file_enumerator_next_files_async (children, 16,
G_PRIORITY_DEFAULT, priv->cancellable,
plugin_manager_next_files_ready, user_data);
}
}
static void
enum_child_cb (GObject *obj, GAsyncResult *result, gpointer data)
{
RBAndroidSource *source = RB_ANDROID_SOURCE (data);
RBAndroidSourcePrivate *priv = GET_PRIVATE(source);
GFileEnumerator *e;
GError *error = NULL;
e = g_file_enumerate_children_finish (G_FILE (obj), result, &error);
if (e == NULL) {
rb_debug ("enum error: %s", error->message);
g_clear_error (&error);
music_dirs_done (source);
return;
}
g_file_enumerator_next_files_async (e, 64, G_PRIORITY_DEFAULT, priv->cancel, enum_files_cb, source);
}
static void
enumerate_children_async_cb (GObject *source,
GAsyncResult *res,
gpointer user_data)
{
EnumerateJob *job = user_data;
GFileEnumerator *enumerator;
enumerator = g_file_enumerate_children_finish (G_FILE (source),
res, NULL);
if (!enumerator) {
enumerate_job_finish (job);
return;
}
g_file_enumerator_next_files_async (enumerator, G_MAXINT,
G_PRIORITY_DEFAULT,
NULL, enumerate_next_files_async_cb, job);
}
static void
got_enum (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
LoadBasenamesData *data = user_data;
if (data->completer == NULL)
{
/* Was cancelled */
load_basenames_data_free (data);
return;
}
data->enumerator = g_file_enumerate_children_finish (G_FILE (source_object), res, NULL);
if (data->enumerator == NULL)
{
data->completer->basename_loader = NULL;
if (data->completer->basenames_dir)
g_object_unref (data->completer->basenames_dir);
g_list_foreach (data->completer->basenames, (GFunc)g_free, NULL);
g_list_free (data->completer->basenames);
/* Mark uptodate with no basenames */
data->completer->basenames_dir = g_object_ref (data->dir);
data->completer->basenames = NULL;
data->completer->basenames_are_escaped = data->should_escape;
load_basenames_data_free (data);
return;
}
g_file_enumerator_next_files_async (data->enumerator,
100,
0,
data->cancellable,
got_more_files, data);
}
static VALUE
fileenumerator_next_files_async(int argc, VALUE *argv, VALUE self)
{
VALUE rbnum_files, rbio_priority, rbcancellable, block;
int num_files;
int io_priority;
GCancellable *cancellable;
rb_scan_args(argc, argv, "12&", &rbnum_files, &rbio_priority, &rbcancellable, &block);
num_files = NUM2INT(rbnum_files);
io_priority = RVAL2IOPRIORITYDEFAULT(rbio_priority);
cancellable = RVAL2GCANCELLABLE(rbcancellable);
SAVE_BLOCK(block);
g_file_enumerator_next_files_async(_SELF(self),
num_files,
io_priority,
cancellable,
rbgio_async_ready_callback,
(gpointer)block);
return self;
}
static void
on_enumerator_ready (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GError *error = NULL;
GFileEnumerator *enumerator;
JsonObject *options;
const gchar *problem;
enumerator = g_file_enumerate_children_finish (G_FILE (source_object), res, &error);
if (enumerator == NULL)
{
if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
{
CockpitFslist *self = COCKPIT_FSLIST (user_data);
problem = error_to_problem (error);
if (problem)
g_debug ("%s: couldn't list directory: %s", self->path, error->message);
else
g_warning ("%s: couldn't list directory: %s", self->path, error->message);
options = cockpit_channel_close_options (COCKPIT_CHANNEL (self));
json_object_set_string_member (options, "message", error->message);
cockpit_channel_close (COCKPIT_CHANNEL (self), problem ? problem : "internal-error");
}
g_clear_error (&error);
return;
}
CockpitFslist *self = COCKPIT_FSLIST (user_data);
g_file_enumerator_next_files_async (enumerator,
10,
G_PRIORITY_DEFAULT,
self->cancellable,
on_files_listed,
self);
}
static void
delete_subdir (GObject *source,
GAsyncResult *res,
gpointer user_data)
{
GFile *file = G_FILE (source);
DeleteData *data = user_data;
GFileEnumerator *enumerator;
GError *error = NULL;
g_debug ("GsdHousekeeping: purging %s in %s\n",
data->trash ? "trash" : "temporary files", data->name);
enumerator = g_file_enumerate_children_finish (file, res, &error);
if (error) {
if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_NOT_DIRECTORY))
g_warning ("Failed to enumerate children of %s: %s\n", data->name, error->message);
}
if (enumerator) {
g_file_enumerator_next_files_async (enumerator, 20,
0,
data->cancellable,
delete_batch,
delete_data_ref (data));
} else if (data->depth > 0 && g_error_matches (error, G_IO_ERROR, G_IO_ERROR_NOT_DIRECTORY)) {
if ((data->trash && data->depth > 1) ||
should_purge_file (data->file, data->cancellable, data->old)) {
g_debug ("Purging %s leaf node", data->name);
if (!data->dry_run) {
g_file_delete (data->file, data->cancellable, NULL);
}
}
}
if (error)
g_error_free (error);
delete_data_unref (data);
}
static void
enumerated_children_callback (GObject *source_object, GAsyncResult *res,
gpointer user_data)
{
GFileEnumerator *enumerator;
InsensitiveFileSearchData *data = (InsensitiveFileSearchData *) (user_data);
enumerator = g_file_enumerate_children_finish (G_FILE (source_object),
res, NULL);
if (enumerator == NULL)
{
GSimpleAsyncResult *simple;
GFile *file;
simple = g_simple_async_result_new (G_OBJECT (data->root),
data->callback,
data->user_data,
_g_find_file_insensitive_async);
file = g_file_get_child (data->root, data->original_path);
g_simple_async_result_set_op_res_gpointer (simple, g_object_ref (file), g_object_unref);
g_simple_async_result_complete_in_idle (simple);
g_object_unref (simple);
clear_find_file_insensitive_state (data);
return;
}
data->enumerator = enumerator;
g_file_enumerator_next_files_async (enumerator,
INSENSITIVE_SEARCH_ITEMS_PER_CALLBACK,
G_PRIORITY_DEFAULT,
data->cancellable,
more_files_callback,
data);
}
static void
plugin_manager_children_ready (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
GigglePluginManagerPriv *priv = GET_PRIV (user_data);
GError *error = NULL;
GFileEnumerator *children;
children = g_file_enumerate_children_finish (G_FILE (object), result, &error);
if (error) {
g_warning ("%s: %s", G_STRFUNC, error->message);
g_clear_error (&error);
}
if (children) {
g_file_enumerator_next_files_async (children, 16,
G_PRIORITY_DEFAULT, priv->cancellable,
plugin_manager_next_files_ready, user_data);
g_object_unref (children);
}
}
static void
on_files_listed (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GError *error = NULL;
JsonObject *options;
GList *files;
files = g_file_enumerator_next_files_finish (G_FILE_ENUMERATOR (source_object), res, &error);
if (error)
{
if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
{
CockpitFslist *self = COCKPIT_FSLIST (user_data);
g_message ("%s: couldn't process files %s", COCKPIT_FSLIST(user_data)->path, error->message);
options = cockpit_channel_close_options (COCKPIT_CHANNEL (self));
json_object_set_string_member (options, "message", error->message);
cockpit_channel_close (COCKPIT_CHANNEL (self), "internal-error");
}
g_clear_error (&error);
return;
}
CockpitFslist *self = COCKPIT_FSLIST (user_data);
if (files == NULL)
{
JsonObject *msg;
GBytes *msg_bytes;
msg = json_object_new ();
json_object_set_string_member (msg, "event", "present-done");
msg_bytes = cockpit_json_write_bytes (msg);
json_object_unref (msg);
cockpit_channel_send (COCKPIT_CHANNEL(self), msg_bytes, FALSE);
g_bytes_unref (msg_bytes);
g_clear_object (&self->cancellable);
g_object_unref (source_object);
if (self->monitor == NULL)
{
cockpit_channel_done (COCKPIT_CHANNEL (self));
cockpit_channel_close (COCKPIT_CHANNEL (self), NULL);
}
return;
}
for (GList *l = files; l; l = l->next)
{
GFileInfo *info = G_FILE_INFO (l->data);
JsonObject *msg;
GBytes *msg_bytes;
msg = json_object_new ();
json_object_set_string_member (msg, "event", "present");
json_object_set_string_member
(msg, "path", g_file_info_get_attribute_byte_string (info, G_FILE_ATTRIBUTE_STANDARD_NAME));
json_object_set_string_member
(msg, "type", cockpit_file_type_to_string (g_file_info_get_file_type (info)));
msg_bytes = cockpit_json_write_bytes (msg);
json_object_unref (msg);
cockpit_channel_send (COCKPIT_CHANNEL(self), msg_bytes, FALSE);
g_bytes_unref (msg_bytes);
}
g_list_free_full (files, g_object_unref);
g_file_enumerator_next_files_async (G_FILE_ENUMERATOR (source_object),
10,
G_PRIORITY_DEFAULT,
self->cancellable,
on_files_listed,
self);
}
static void
got_more_files (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
LoadBasenamesData *data = user_data;
GList *infos, *l;
GFileInfo *info;
const char *name;
gboolean append_slash;
char *t;
char *basename;
if (data->completer == NULL)
{
/* Was cancelled */
load_basenames_data_free (data);
return;
}
infos = g_file_enumerator_next_files_finish (data->enumerator, res, NULL);
for (l = infos; l != NULL; l = l->next)
{
info = l->data;
if (data->dirs_only &&
g_file_info_get_file_type (info) != G_FILE_TYPE_DIRECTORY)
{
g_object_unref (info);
continue;
}
append_slash = g_file_info_get_file_type (info) == G_FILE_TYPE_DIRECTORY;
name = g_file_info_get_name (info);
if (name == NULL)
{
g_object_unref (info);
continue;
}
if (data->should_escape)
basename = g_uri_escape_string (name,
G_URI_RESERVED_CHARS_ALLOWED_IN_PATH,
TRUE);
else
/* If not should_escape, must be a local filename, convert to utf8 */
basename = g_filename_to_utf8 (name, -1, NULL, NULL, NULL);
if (basename)
{
if (append_slash)
{
t = basename;
basename = g_strconcat (basename, "/", NULL);
g_free (t);
}
data->basenames = g_list_prepend (data->basenames, basename);
}
g_object_unref (info);
}
g_list_free (infos);
if (infos)
{
/* Not last, get more files */
g_file_enumerator_next_files_async (data->enumerator,
100,
0,
data->cancellable,
got_more_files, data);
}
else
{
data->completer->basename_loader = NULL;
if (data->completer->basenames_dir)
g_object_unref (data->completer->basenames_dir);
g_list_foreach (data->completer->basenames, (GFunc)g_free, NULL);
g_list_free (data->completer->basenames);
data->completer->basenames_dir = g_object_ref (data->dir);
data->completer->basenames = data->basenames;
data->completer->basenames_are_escaped = data->should_escape;
data->basenames = NULL;
g_file_enumerator_close_async (data->enumerator, 0, NULL, NULL, NULL);
g_signal_emit (data->completer, signals[GOT_COMPLETION_DATA], 0);
load_basenames_data_free (data);
}
}
static void
more_files_callback (GObject *source_object, GAsyncResult *res,
gpointer user_data)
{
InsensitiveFileSearchData *data = (InsensitiveFileSearchData *) (user_data);
GList *files, *l;
gchar *filename = NULL, *component, *case_folded_name,
*name_collation_key;
gboolean end_of_files, is_utf8;
files = g_file_enumerator_next_files_finish (data->enumerator,
res, NULL);
end_of_files = files == NULL;
component = data->split_path[data->index];
g_return_if_fail (component != NULL);
is_utf8 = (g_utf8_validate (component, -1, NULL));
if (is_utf8)
{
case_folded_name = g_utf8_casefold (component, -1);
name_collation_key = g_utf8_collate_key (case_folded_name, -1);
g_free (case_folded_name);
}
else
{
name_collation_key = g_ascii_strdown (component, -1);
}
for (l = files; l != NULL; l = l->next)
{
GFileInfo *info;
const gchar *this_name;
gchar *key;
info = l->data;
this_name = g_file_info_get_name (info);
if (is_utf8 && g_utf8_validate (this_name, -1, NULL))
{
gchar *case_folded;
case_folded = g_utf8_casefold (this_name, -1);
key = g_utf8_collate_key (case_folded, -1);
g_free (case_folded);
}
else
{
key = g_ascii_strdown (this_name, -1);
}
if (strcmp (key, name_collation_key) == 0)
filename = g_strdup (this_name);
g_free (key);
if (filename)
break;
}
g_list_free_full (files, g_object_unref);
g_free (name_collation_key);
if (filename)
{
GFile *next_file;
g_file_enumerator_close_async (data->enumerator,
G_PRIORITY_DEFAULT,
data->cancellable,
NULL, NULL);
g_object_unref (data->enumerator);
data->enumerator = NULL;
/* Set the current file and continue searching */
next_file = g_file_get_child (data->current_file, filename);
g_free (filename);
g_object_unref (data->current_file);
data->current_file = next_file;
data->index++;
/* Skip any empty components due to multiple slashes */
while (data->split_path[data->index] != NULL &&
*data->split_path[data->index] == 0)
data->index++;
if (data->split_path[data->index] == NULL)
{
/* Search is complete, file was found */
GSimpleAsyncResult *simple;
simple = g_simple_async_result_new (G_OBJECT (data->root),
data->callback,
data->user_data,
_g_find_file_insensitive_async);
g_simple_async_result_set_op_res_gpointer (simple, g_object_ref (data->current_file), g_object_unref);
g_simple_async_result_complete_in_idle (simple);
g_object_unref (simple);
clear_find_file_insensitive_state (data);
return;
}
/* Continue searching down the tree */
g_file_enumerate_children_async (data->current_file,
G_FILE_ATTRIBUTE_STANDARD_NAME,
0, G_PRIORITY_DEFAULT,
data->cancellable,
enumerated_children_callback,
data);
return;
}
if (end_of_files)
{
/* Could not find the given file, abort the search */
GSimpleAsyncResult *simple;
GFile *file;
g_object_unref (data->enumerator);
data->enumerator = NULL;
simple = g_simple_async_result_new (G_OBJECT (data->root),
data->callback,
data->user_data,
_g_find_file_insensitive_async);
file = g_file_get_child (data->root, data->original_path);
g_simple_async_result_set_op_res_gpointer (simple, file, g_object_unref);
g_simple_async_result_complete_in_idle (simple);
g_object_unref (simple);
clear_find_file_insensitive_state (data);
return;
}
/* Continue enumerating */
g_file_enumerator_next_files_async (data->enumerator,
INSENSITIVE_SEARCH_ITEMS_PER_CALLBACK,
G_PRIORITY_DEFAULT,
data->cancellable,
more_files_callback,
data);
}
static void
enum_files_cb (GObject *obj, GAsyncResult *result, gpointer data)
{
RBAndroidSource *source = RB_ANDROID_SOURCE (data);
RBAndroidSourcePrivate *priv = GET_PRIVATE(source);
GFileEnumerator *e = G_FILE_ENUMERATOR (obj);
GError *error = NULL;
GFileInfo *info;
GList *files;
GList *l;
files = g_file_enumerator_next_files_finish (e, result, &error);
if (error != NULL) {
rb_debug ("error listing files: %s", error->message);
music_dirs_done (source);
return;
}
if (files == NULL) {
priv->scanned++;
g_object_unref (e);
find_music_dirs (source);
return;
}
for (l = files; l != NULL; l = l->next) {
guint32 filetype;
info = (GFileInfo *)l->data;
filetype = g_file_info_get_attribute_uint32 (info, G_FILE_ATTRIBUTE_STANDARD_TYPE);
if (filetype == G_FILE_TYPE_DIRECTORY) {
GFile *dir;
if (priv->scanned == 0) {
rb_debug ("got storage container %s", g_file_info_get_name (info));
dir = g_file_get_child (g_file_enumerator_get_container (e), g_file_info_get_name (info));
g_queue_push_tail (&priv->to_scan, dir);
} else if (g_ascii_strcasecmp (g_file_info_get_name (info), "music") == 0) {
GFile *storage;
char *uri;
storage = g_file_enumerator_get_container (e);
dir = g_file_get_child (storage, g_file_info_get_name (info));
uri = g_file_get_uri (dir);
rb_debug ("music dir found at %s", uri);
/* keep the container around for space/capacity calculation */
priv->storage = g_list_append (priv->storage, dir);
rhythmdb_import_job_add_uri (priv->import_job, uri);
g_free (uri);
}
}
g_object_unref (info);
}
g_list_free (files);
g_file_enumerator_next_files_async (G_FILE_ENUMERATOR (obj), 64, G_PRIORITY_DEFAULT, priv->cancel, enum_files_cb, source);
}
