static gboolean
ignore_mount (GMount *mount)
{
GFile *root;
GVolume *volume;
gboolean ret = TRUE;
root = g_mount_get_root (mount);
if (g_file_has_uri_scheme (root, "burn") != FALSE || g_file_has_uri_scheme (root, "cdda") != FALSE) {
/* We don't add Audio CDs, or blank media */
g_object_unref (root);
GRL_DEBUG ("%s: Not adding mount %s as is burn or cdda", __FUNCTION__,
g_mount_get_name (mount));
return TRUE;
}
g_object_unref (root);
volume = g_mount_get_volume (mount);
if (volume == NULL)
return ret;
ret = ignore_volume (volume);
g_object_unref (volume);
return ret;
}
static gboolean
rb_ipod_db_load (RbIpodDb *ipod_db, GMount *mount)
{
GFile *mount_root;
char *mount_path;
const Itdb_IpodInfo *info;
RbIpodDbPrivate *priv = IPOD_DB_GET_PRIVATE (ipod_db);
mount_root = g_mount_get_root (mount);
if (mount_root == NULL) {
return FALSE;
}
mount_path = g_file_get_path (mount_root);
g_object_unref (mount_root);
priv->itdb = itdb_parse (mount_path, NULL);
g_free (mount_path);
if (priv->itdb == NULL) {
return FALSE;
}
info = itdb_device_get_ipod_info (priv->itdb->device);
if (info->ipod_generation == ITDB_IPOD_GENERATION_UNKNOWN ||
info->ipod_generation == ITDB_IPOD_GENERATION_SHUFFLE_1 ||
info->ipod_generation == ITDB_IPOD_GENERATION_SHUFFLE_2 ||
info->ipod_generation == ITDB_IPOD_GENERATION_SHUFFLE_3) {
priv->needs_shuffle_db = TRUE;
} else {
priv->needs_shuffle_db = FALSE;
}
return TRUE;
}
static void
device_chooser_changed_cb (GtkWidget *widget,
DialogData *data)
{
GtkTreeIter iter;
GMount *mount;
if (! gtk_combo_box_get_active_iter (GTK_COMBO_BOX (data->device_chooser), &iter)) {
_g_clear_object (&data->source);
_g_clear_object (&data->last_source);
gth_file_list_clear (GTH_FILE_LIST (data->file_list), _("(Empty)"));
return;
}
gtk_tree_model_get (GTK_TREE_MODEL (data->device_list_store), &iter,
SOURCE_LIST_COLUMN_MOUNT, &mount,
-1);
if (mount == NULL) {
_g_clear_object (&data->source);
_g_clear_object (&data->last_source);
gth_file_list_clear (GTH_FILE_LIST (data->file_list), _("Empty"));
return;
}
_g_object_unref (data->source);
data->source = g_mount_get_root (mount);
load_file_list (data);
g_object_unref (mount);
}
static GtkWidget *
panel_menu_item_mount_new (GMount *mount)
{
GtkWidget *item;
GFile *root;
GIcon *icon;
char *display_name;
char *activation_uri;
icon = g_mount_get_icon (mount);
display_name = g_mount_get_name (mount);
root = g_mount_get_root (mount);
activation_uri = g_file_get_uri (root);
g_object_unref (root);
item = panel_menu_item_uri_new (activation_uri, NULL, icon,
display_name,
display_name, //FIXME tooltip
G_CALLBACK (activate_uri));
g_object_unref (icon);
g_free (display_name);
g_free (activation_uri);
return item;
}
void GioLister::UpdateDeviceFreeSpace(const QString& id) {
{
QMutexLocker l(&mutex_);
if (!devices_.contains(id))
return;
DeviceInfo& device_info = devices_[id];
GFile* root = g_mount_get_root(device_info.mount);
GError* error = NULL;
GFileInfo* info = g_file_query_filesystem_info(
root, G_FILE_ATTRIBUTE_FILESYSTEM_FREE, NULL, &error);
if (error) {
qLog(Warning) << error->message;
g_error_free(error);
} else {
device_info.filesystem_free = g_file_info_get_attribute_uint64(
info, G_FILE_ATTRIBUTE_FILESYSTEM_FREE);
g_object_unref(info);
}
g_object_unref(root);
}
emit DeviceChanged(id);
}
static char *
shell_util_get_file_display_name_if_mount (GFile *file)
{
GFile *compare;
GVolumeMonitor *monitor;
GList *mounts, *l;
char *ret;
ret = NULL;
/* compare with all mounts */
monitor = g_volume_monitor_get ();
mounts = g_volume_monitor_get_mounts (monitor);
for (l = mounts; l != NULL; l = l->next)
{
GMount *mount;
mount = G_MOUNT(l->data);
compare = g_mount_get_root (mount);
if (!ret && g_file_equal (file, compare))
ret = g_mount_get_name (mount);
g_object_unref (mount);
}
g_list_free (mounts);
g_object_unref (monitor);
return ret;
}
static gboolean
bookmark_location_mounted_callback (NemoBookmark *bookmark,
GFile *location,
NemoBookmarkList *bookmarks)
{
gboolean ret = FALSE;
GList *volumes = g_volume_monitor_get_mounts (bookmarks->volume_monitor);
GList *iter = volumes;
while (iter != NULL) {
GMount *mount = G_MOUNT (iter->data);
GFile *mount_location = g_mount_get_root (mount);
gchar *mount_root_uri = g_file_get_uri (mount_location);
gchar *location_uri = g_file_get_uri (location);
ret = g_str_has_prefix (location_uri, mount_root_uri);
g_free (mount_root_uri);
g_free (location_uri);
g_object_unref (mount_location);
if (ret == TRUE)
break;
iter = iter->next;
}
g_list_free_full (volumes, (GDestroyNotify) g_object_unref);
return ret;
}
gchar *
rb_uri_get_mount_point (const char *uri)
{
GFile *file;
GMount *mount;
char *mountpoint;
GError *error = NULL;
file = g_file_new_for_uri (uri);
mount = g_file_find_enclosing_mount (file, NULL, &error);
if (error != NULL) {
if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND) == FALSE) {
rb_debug ("finding mount for %s: %s", uri, error->message);
}
g_error_free (error);
mountpoint = NULL;
} else {
GFile *root;
root = g_mount_get_root (mount);
mountpoint = g_file_get_uri (root);
g_object_unref (root);
g_object_unref (mount);
}
g_object_unref (file);
return mountpoint;
}
static void
print_mounts (const char *prefix)
{
GList *l;
GList *mounts;
GVolumeMonitor *volume_monitor;
volume_monitor = g_volume_monitor_get ();
mounts = g_volume_monitor_get_mounts (volume_monitor);
if (mounts != NULL)
{
for (l = mounts; l != NULL; l = l->next)
{
GMount *mount = l->data;
GFile *mount_root;
char *uri;
mount_root = g_mount_get_root (mount);
uri = g_file_get_uri (mount_root);
if (prefix == NULL ||
g_str_has_prefix (uri, prefix))
g_print ("%s\n", uri);
g_free (uri);
g_object_unref (mount_root);
g_object_unref (mount);
}
g_list_free (mounts);
}
g_object_unref (volume_monitor);
if (prefix == NULL || g_str_has_prefix ("file:///", prefix))
g_print ("file:///\n");
}
void on_mount_added(GVolumeMonitor* vm, GMount* mount, gpointer user_data)
{
FmPlacesModel* model = FM_PLACES_MODEL(user_data);
GVolume* vol = g_mount_get_volume(mount);
if(vol)
{
FmPlaceItem *item;
GtkTreeIter it;
item = find_vol(model, vol, &it);
if(item && item->type == FM_PLACES_ITEM_VOL && !item->fi->path)
{
GtkTreePath* tp;
GFile* gf = g_mount_get_root(mount);
FmPath* path = fm_path_new_for_gfile(gf);
g_debug("mount path: %s", path->name);
g_object_unref(gf);
fm_file_info_set_path(item->fi, path);
if(path)
fm_path_unref(path);
item->vol_mounted = TRUE;
/* inform the view to update mount indicator */
tp = gtk_tree_model_get_path(GTK_TREE_MODEL(model), &it);
gtk_tree_model_row_changed(GTK_TREE_MODEL(model), tp, &it);
gtk_tree_path_free(tp);
}
g_object_unref(vol);
}
}
static guint
impl_want_uri (RBSource *source, const char *uri)
{
GVolume *volume;
GMount *mount;
GFile *file;
int retval;
retval = 0;
file = g_file_new_for_uri (uri);
if (g_file_has_uri_scheme (file, "cdda") == FALSE) {
g_object_unref (file);
return 0;
}
g_object_get (G_OBJECT (source),
"volume", &volume,
NULL);
if (volume == NULL)
return 0;
mount = g_volume_get_mount (volume);
if (mount) {
GFile *root;
root = g_mount_get_root (mount);
retval = g_file_equal (root, file) ? 100 : 0;
g_object_unref (mount);
g_object_unref (root);
}
g_object_unref (file);
return retval;
}
static gboolean
check_audio_cd (GVolume *volume)
{
GFile *file;
char *activation_uri;
GMount *mount;
if (!volume)
return FALSE;
mount = g_volume_get_mount (volume);
if (!mount)
return FALSE;
file = g_mount_get_root (mount);
g_object_unref (mount);
if (!file)
return FALSE;
activation_uri = g_file_get_uri (file);
g_object_unref (file);
/* we have an audioCD if the activation URI starts by 'cdda://' */
gboolean result = (strncmp ("cdda://", activation_uri, 7) == 0);
g_free (activation_uri);
return result;
}
static void
panel_menu_item_append_mount (GtkWidget *menu,
GMount *mount)
{
GFile *root;
GIcon *icon;
char *display_name;
char *activation_uri;
icon = g_mount_get_icon (mount);
display_name = g_mount_get_name (mount);
root = g_mount_get_root (mount);
activation_uri = g_file_get_uri (root);
g_object_unref (root);
panel_menu_items_append_place_item (NULL, icon,
display_name,
display_name, //FIXME tooltip
menu,
G_CALLBACK (activate_uri),
activation_uri);
g_object_unref (icon);
g_free (display_name);
g_free (activation_uri);
}
static gboolean
can_delete_directory (RBAndroidSource *source, GFile *dir)
{
GMount *mount;
GFile *root;
char *path;
int i;
int c;
g_object_get (source, "mount", &mount, NULL);
root = g_mount_get_root (mount);
g_object_unref (mount);
/*
* path here will be sdcard/Music/something for anything we want to delete
*/
path = g_file_get_relative_path (root, dir);
c = 0;
for (i = 0; path[i] != '\0'; i++) {
if (path[i] == '/')
c++;
}
g_free (path);
return (c > 1);
}
static void
unmount_all_with_scheme (const char *scheme)
{
GVolumeMonitor *volume_monitor;
GList *mounts;
GList *l;
volume_monitor = g_volume_monitor_get();
/* populate gvfs network mounts */
iterate_gmain();
mounts = g_volume_monitor_get_mounts (volume_monitor);
for (l = mounts; l != NULL; l = l->next) {
GMount *mount = G_MOUNT (l->data);
GFile *root;
root = g_mount_get_root (mount);
if (g_file_has_uri_scheme (root, scheme)) {
unmount (root);
}
g_object_unref (root);
}
g_list_foreach (mounts, (GFunc)g_object_unref, NULL);
g_list_free (mounts);
g_object_unref (volume_monitor);
}
static void on_dlg_response(GtkDialog* dlg, int res, gpointer user_data)
{
AutoRun* data = (AutoRun*)user_data;
/* stop the detection */
g_cancellable_cancel(data->cancel);
if(res == GTK_RESPONSE_OK)
{
GtkTreeModel* model;
GtkTreeSelection* sel = gtk_tree_view_get_selection(data->view);
GtkTreeIter it;
if( gtk_tree_selection_get_selected(sel, &model, &it) )
{
GAppInfo* app;
gtk_tree_model_get(model, &it, 2, &app, -1);
if(app)
{
GFile* gf = g_mount_get_root(data->mount);
GList* filelist = g_list_prepend(NULL, gf);
g_app_info_launch(app, filelist, NULL, NULL);
g_list_free(filelist);
g_object_unref(gf);
g_object_unref(app);
}
else
{
GFile* gf = g_mount_get_root(data->mount);
FmPath* path = fm_path_new_for_gfile(gf);
fm_main_win_add_win(NULL, path);
fm_path_unref(path);
g_object_unref(gf);
}
}
}
g_signal_handlers_disconnect_by_func(dlg, on_dlg_response, data);
g_signal_handlers_disconnect_by_func(data->view, on_row_activated, data);
g_signal_handlers_disconnect_by_func(data->mount, on_unmount, data);
gtk_widget_destroy(GTK_WIDGET(dlg));
g_object_unref(data->cancel);
g_object_unref(data->store);
g_object_unref(data->mount);
g_slice_free(AutoRun, data);
pcmanfm_unref();
}
static void
rb_removable_media_manager_add_mount (RBRemovableMediaManager *mgr, GMount *mount)
{
RBRemovableMediaManagerPrivate *priv = GET_PRIVATE (mgr);
RBSource *source = NULL;
GVolume *volume;
GFile *mount_root;
char *mountpoint;
MPIDDevice *device_info;
g_assert (mount != NULL);
if (g_hash_table_lookup (priv->mount_mapping, mount) != NULL) {
return;
}
if (g_mount_is_shadowed (mount) != FALSE) {
return;
}
volume = g_mount_get_volume (mount);
if (volume == NULL) {
rb_debug ("Unhandled media, no volume for mount");
return;
}
/* if we've already created a source for the volume,
* don't do anything with the mount.
*/
if (g_hash_table_lookup (priv->volume_mapping, volume) != NULL) {
rb_debug ("already created a source for the volume, so ignoring the mount");
g_object_unref (volume);
return;
}
dump_volume_identifiers (volume);
g_object_unref (volume);
/* look the device up in the device info database */
mount_root = g_mount_get_root (mount);
if (mount_root == NULL) {
rb_debug ("unable to get mount root, can't create a source for this mount");
return;
}
mountpoint = g_file_get_path (mount_root);
g_object_unref (mount_root);
device_info = mpid_device_new (mountpoint);
g_free (mountpoint);
g_signal_emit (G_OBJECT (mgr), rb_removable_media_manager_signals[CREATE_SOURCE_MOUNT], 0, mount, device_info, &source);
if (source) {
g_hash_table_insert (priv->mount_mapping, mount, source);
rb_removable_media_manager_append_media_source (mgr, source);
} else {
rb_debug ("Unhandled media");
}
g_object_unref (device_info);
}
gboolean
rb_ipod_helpers_is_ipod (GMount *mount, MPIDDevice *device_info)
{
GFile *root;
gboolean result = FALSE;
char **protocols;
/* if we have specific information about the device, use it.
* otherwise, check if the device has an ipod device directory on it.
*/
g_object_get (device_info, "access-protocols", &protocols, NULL);
if (protocols != NULL && g_strv_length (protocols) > 0) {
int i;
for (i = 0; protocols[i] != NULL; i++) {
if (g_str_equal (protocols[i], "ipod")) {
result = TRUE;
break;
}
}
} else {
root = g_mount_get_root (mount);
if (root != NULL) {
gchar *device_dir;
if (g_file_has_uri_scheme (root, "afc") != FALSE) {
gchar *uri;
uri = g_file_get_uri (root);
/* afc://<40 chars>:stuff */
g_assert (strlen (uri) >= 46);
if (uri[6 + 40] == ':' &&
uri[6 + 40 + 1] != '1') {
result = FALSE;
} else {
result = TRUE;
}
g_free (uri);
} else {
gchar *mount_point;
mount_point = g_file_get_path (root);
if (mount_point != NULL) {
device_dir = itdb_get_device_dir (mount_point);
if (device_dir != NULL) {
result = g_file_test (device_dir,
G_FILE_TEST_IS_DIR);
g_free (device_dir);
}
}
g_free (mount_point);
}
g_object_unref (root);
}
}
g_strfreev (protocols);
return result;
}
static GList *
add_volume (GList *media_list,
GVolume *volume,
GDrive *drive,
GrlOpticalMediaSource *source)
{
char *name, *icon_uri;
GIcon *icon;
char *device_path, *id;
GrlMedia * media;
GMount *mount;
device_path = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE);
if (device_path == NULL)
return media_list;
/* Is it an audio CD or a blank media */
mount = g_volume_get_mount (volume);
if (mount != NULL) {
GFile *root;
root = g_mount_get_root (mount);
g_object_unref (mount);
if (g_file_has_uri_scheme (root, "burn") != FALSE || g_file_has_uri_scheme (root, "cdda") != FALSE) {
/* We don't add Audio CDs, or blank media */
g_object_unref (root);
g_free (device_path);
return media_list;
}
g_object_unref (root);
}
media = grl_media_video_new ();
id = g_filename_to_uri (device_path, NULL, NULL);
g_free (device_path);
grl_media_set_id (media, id);
g_free (id);
/* Work out an icon to display */
icon = g_volume_get_icon (volume);
icon_uri = get_uri_for_gicon (icon);
g_object_unref (icon);
grl_media_set_thumbnail (media, icon_uri);
g_free (icon_uri);
/* Get the volume's pretty name for the menu label */
name = g_volume_get_name (volume);
g_strstrip (name);
grl_media_set_title (media, name);
g_free (name);
grl_media_set_mime (media, "x-special/device-block");
return g_list_prepend (media_list, media);
}
static GFile* get_volume_root(GVolume* volume) {
GFile* root = NULL;
if (is_sdb(volume)) {
GMount* mount = g_volume_get_mount(volume);
root = g_mount_get_root(mount);
g_object_unref(mount);
}
return root;
}
// -------------------------------------------------------------------------------- //
void guGIO_VolumeMonitor::OnMountAdded( GMount * mount )
{
guLogMessage( wxT( "Mount Added..." ) );
if( FindMount( mount ) == wxNOT_FOUND )
{
if( g_mount_is_shadowed( mount ) )
{
//g_object_unref( mount );
guLogMessage( wxT( "ignored shadowed mount" ) );
return;
}
GVolume * Volume = g_mount_get_volume( mount );
if( !Volume )
{
guLogMessage( wxT( "mount without volume?" ) );
//g_object_unref( mount );
return;
}
g_object_unref( Volume );
GFile * MountRoot = g_mount_get_root( mount );
if( MountRoot )
{
char * mount_path = g_file_get_path( MountRoot );
if( mount_path )
{
wxString MountPath = wxString( mount_path, wxConvUTF8 );
guGIO_Mount * Mount = new guGIO_Mount( mount, MountPath );
if( Mount )
{
m_MountedVolumes->Add( Mount );
wxCommandEvent event( wxEVT_COMMAND_MENU_SELECTED, ID_VOLUMEMANAGER_MOUNT_CHANGED );
event.SetInt( 1 );
wxPostEvent( m_MainFrame, event );
}
g_free( mount_path );
}
g_object_unref( MountRoot );
}
else
{
guLogMessage( wxT( "ignored mount without mount root" ) );
g_object_unref( mount );
return;
}
}
else
{
guLogMessage( wxT( "Mount already added?" ) );
}
}
static GObject *
impl_constructor (GType type,
guint n_construct_properties,
GObjectConstructParam *construct_properties)
{
RBGenericPlayerSource *source;
RBGenericPlayerSourcePrivate *priv;
GMount *mount;
char *mount_name;
RBShell *shell;
GFile *root;
GFileInfo *info;
GError *error = NULL;
source = RB_GENERIC_PLAYER_SOURCE (G_OBJECT_CLASS (rb_generic_player_source_parent_class)->
constructor (type, n_construct_properties, construct_properties));
priv = GENERIC_PLAYER_SOURCE_GET_PRIVATE (source);
g_object_get (source, "shell", &shell, NULL);
g_object_get (shell, "db", &priv->db, NULL);
priv->import_errors = rb_import_errors_source_new (shell, priv->error_type);
g_object_unref (shell);
g_object_get (source, "mount", &mount, NULL);
root = g_mount_get_root (mount);
mount_name = g_mount_get_name (mount);
info = g_file_query_filesystem_info (root, G_FILE_ATTRIBUTE_FILESYSTEM_READONLY, NULL, &error);
if (error != NULL) {
rb_debug ("error querying filesystem info for %s: %s", mount_name, error->message);
g_error_free (error);
priv->read_only = FALSE;
} else {
priv->read_only = g_file_info_get_attribute_boolean (info, G_FILE_ATTRIBUTE_FILESYSTEM_READONLY);
g_object_unref (info);
}
g_free (mount_name);
g_object_unref (root);
g_object_unref (mount);
priv->folder_depth = -1; /* 0 is a possible value, I guess */
priv->playlist_format_unknown = TRUE;
get_device_info (source);
load_songs (source);
return G_OBJECT (source);
}
static void update_vol(FmPlacesModel* model, FmPlaceItem* item, GtkTreeIter* it, FmFileInfoJob* job)
{
FmIcon* icon;
GIcon* gicon;
char* name;
GdkPixbuf* pix;
GMount* mount;
FmPath* path;
name = g_volume_get_name(item->vol);
if(item->fi->icon)
fm_icon_unref(item->fi->icon);
gicon = g_volume_get_icon(item->vol);
icon = fm_icon_from_gicon(gicon);
item->fi->icon = icon;
g_object_unref(gicon);
mount = g_volume_get_mount(item->vol);
if(mount)
{
GFile* gf = g_mount_get_root(mount);
path = fm_path_new_for_gfile(gf);
g_object_unref(gf);
g_object_unref(mount);
item->vol_mounted = TRUE;
}
else
{
path = NULL;
item->vol_mounted = FALSE;
}
if(!fm_path_equal(item->fi->path, path))
{
fm_file_info_set_path(item->fi, path);
if(path)
{
if(job)
fm_file_info_job_add(job, path);
else
{
job = fm_file_info_job_new(NULL, FM_FILE_INFO_JOB_FOLLOW_SYMLINK);
model->jobs = g_slist_prepend(model->jobs, job);
g_signal_connect(job, "finished", G_CALLBACK(on_file_info_job_finished), model);
fm_job_run_async(FM_JOB(job));
}
fm_path_unref(path);
}
}
pix = fm_icon_get_pixbuf(item->fi->icon, fm_config->pane_icon_size);
gtk_list_store_set(GTK_LIST_STORE(model), it, FM_PLACES_MODEL_COL_ICON, pix, FM_PLACES_MODEL_COL_LABEL, name, -1);
g_object_unref(pix);
g_free(name);
}
static char *
create_mount_id (GMount *mount)
{
GFile *root;
char *uri;
root = g_mount_get_root (mount);
uri = g_file_get_uri (root);
g_object_unref (root);
return uri;
}
void activate_row(FmPlacesView* view, guint button, GtkTreePath* tree_path)
{
GtkTreeIter it;
if(gtk_tree_model_get_iter(GTK_TREE_MODEL(model), &it, tree_path))
{
FmPlaceItem* item;
FmPath* path;
gtk_tree_model_get(GTK_TREE_MODEL(model), &it, FM_PLACES_MODEL_COL_INFO, &item, -1);
if(!item)
return;
switch(item->type)
{
case FM_PLACES_ITEM_PATH:
path = fm_path_ref(item->fi->path);
break;
case FM_PLACES_ITEM_VOL:
{
GFile* gf;
GMount* mnt = g_volume_get_mount(item->vol);
if(!mnt)
{
GtkWindow* parent = GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(view)));
if(!fm_mount_volume(parent, item->vol, TRUE))
return;
mnt = g_volume_get_mount(item->vol);
if(!mnt)
{
g_debug("GMount is invalid after successful g_volume_mount().\nThis is quite possibly a gvfs bug.\nSee https://bugzilla.gnome.org/show_bug.cgi?id=552168");
return;
}
}
gf = g_mount_get_root(mnt);
g_object_unref(mnt);
if(gf)
{
path = fm_path_new_for_gfile(gf);
g_object_unref(gf);
}
else
path = NULL;
break;
}
default:
return;
}
if(path)
{
g_signal_emit(view, signals[CHDIR], 0, button, path);
fm_path_unref(path);
}
}
}
int32_t dt_camera_import_backup_job_run(dt_job_t *job)
{
// copy sourcefile to each found destination
dt_camera_import_backup_t *t = (dt_camera_import_backup_t *)job->param;
GVolumeMonitor *vmgr= g_volume_monitor_get();
GList *mounts=g_volume_monitor_get_mounts(vmgr);
GMount *mount=NULL;
GFile *root=NULL;
if( mounts !=NULL )
do
{
mount=G_MOUNT(mounts->data);
if( ( root=g_mount_get_root( mount ) ) != NULL )
{
// Got the mount point lets check for backup folder
gchar *backuppath=NULL;
gchar *rootpath=g_file_get_path(root);
backuppath=g_build_path(G_DIR_SEPARATOR_S,rootpath,dt_conf_get_string("plugins/capture/backup/foldername"),(char *)NULL);
g_free(rootpath);
if( g_file_test(backuppath,G_FILE_TEST_EXISTS)==TRUE)
{
// Found a backup storage, lets copy file here..
gchar *destinationfile=g_build_filename(G_DIR_SEPARATOR_S,backuppath,t->destinationfile,(char *)NULL);
if( g_mkdir_with_parents(g_path_get_dirname(destinationfile),0755) >= 0 )
{
gchar *content;
gsize size;
if( g_file_get_contents(t->sourcefile,&content,&size,NULL) == TRUE )
{
GError *err=NULL;
if( g_file_set_contents(destinationfile,content,size,&err) != TRUE)
{
fprintf(stderr,"Failed to set content of file with reason: %s\n",err->message);
g_error_free(err);
}
g_free(content);
}
}
g_free(destinationfile);
}
g_free(backuppath);
}
}
while( (mounts=g_list_next(mounts)) !=NULL);
// Release volume manager
g_object_unref(vmgr);
return 0;
}
static gboolean
ensure_loaded (RBAndroidSource *source)
{
RBAndroidSourcePrivate *priv = GET_PRIVATE (source);
RBSourceLoadStatus status;
RhythmDBEntryType *entry_type;
GMount *mount;
GFile *root;
RBTaskList *tasklist;
RBShell *shell;
char *name;
char *label;
if (priv->loaded) {
g_object_get (source, "load-status", &status, NULL);
return (status == RB_SOURCE_LOAD_STATUS_LOADED);
}
priv->loaded = TRUE;
rb_media_player_source_load (RB_MEDIA_PLAYER_SOURCE (source));
/* identify storage containers and find music dirs within them */
g_object_get (source, "mount", &mount, "entry-type", &entry_type, NULL);
root = g_mount_get_root (mount);
g_object_unref (mount);
priv->cancel = g_cancellable_new ();
priv->import_job = rhythmdb_import_job_new (priv->db, entry_type, priv->ignore_type, priv->error_type);
g_signal_connect_object (priv->import_job, "complete", G_CALLBACK (import_complete_cb), source, 0);
priv->scanned = 0;
g_queue_init (&priv->to_scan);
g_queue_push_tail (&priv->to_scan, root);
g_object_unref (entry_type);
find_music_dirs (RB_ANDROID_SOURCE (source));
g_object_get (source, "name", &name, "shell", &shell, NULL);
label = g_strdup_printf (_("Scanning %s"), name);
g_object_set (priv->import_job, "task-label", label, NULL);
g_object_get (shell, "task-list", &tasklist, NULL);
rb_task_list_add_task (tasklist, RB_TASK_PROGRESS (priv->import_job));
g_object_unref (tasklist);
g_object_unref (shell);
g_free (label);
g_free (name);
return FALSE;
}
static GFile *
find_music_dir (GMount *mount)
{
GFile *root;
GFile *music_dir = NULL;
root = g_mount_get_root (mount);
if (root != NULL) {
music_dir = find_dir_no_case (root, TRUE);
/* FIXME create directories if they don't exist */
g_object_unref (root);
}
return music_dir;
}
static void prepare_unmount(GMount* mount)
{
/* ensure that CWD is not on the mounted filesystem. */
char* cwd_str = g_get_current_dir();
GFile* cwd = g_file_new_for_path(cwd_str);
GFile* root = g_mount_get_root(mount);
g_free(cwd_str);
/* FIXME: This cannot cover 100% cases since symlinks are not checked.
* There may be other cases that cwd is actually under mount root
* but checking prefix is not enough. We already did our best, though. */
if(g_file_has_prefix(cwd, root))
g_chdir("/");
g_object_unref(cwd);
g_object_unref(root);
}
static void on_mount_added(GObject* vm, GMount* mount, GtkWidget* window) {
GFile* usb_root;
GVolume* volume = g_mount_get_volume(mount);
if (is_sdb(volume)) {
usb_root = g_mount_get_root(mount);
printf("USB drive plugged in.\n");
}
g_object_unref(volume);
if (usb_root != NULL) {
g_signal_handlers_disconnect_by_func(vm, G_CALLBACK(on_mount_added), NULL);
g_signal_connect(vm, "mount-removed", G_CALLBACK(on_mount_removed), NULL);
gtk_window_close(GTK_WINDOW(window));
start_gui(usb_root);
}
}
