| /* GIO - GLib Input, Output and Streaming Library |
| * |
| * Copyright (C) 2014 Patrick Griffis |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General |
| * Public License along with this library; if not, see <http://www.gnu.org/licenses/>. |
| * |
| */ |
| |
| #include "config.h" |
| |
| #include "gappinfo.h" |
| #include "gosxappinfo.h" |
| #include "gcontenttype.h" |
| #include "gfile.h" |
| #include "gfileicon.h" |
| #include "gioerror.h" |
| |
| #import <CoreFoundation/CoreFoundation.h> |
| #import <Foundation/Foundation.h> |
| #import <ApplicationServices/ApplicationServices.h> |
| |
| /** |
| * SECTION:gosxappinfo |
| * @title: GOsxAppInfo |
| * @short_description: Application information from NSBundles |
| * @include: gio/gosxappinfo.h |
| * |
| * #GOsxAppInfo is an implementation of #GAppInfo based on NSBundle information. |
| * |
| * Note that `<gio/gosxappinfo.h>` is unique to OSX. |
| */ |
| |
| static void g_osx_app_info_iface_init (GAppInfoIface *iface); |
| static const char *g_osx_app_info_get_id (GAppInfo *appinfo); |
| |
| /** |
| * GOsxAppInfo: |
| * |
| * Information about an installed application from a NSBundle. |
| */ |
| struct _GOsxAppInfo |
| { |
| GObject parent_instance; |
| |
| NSBundle *bundle; |
| |
| /* Note that these are all NULL until first call |
| * to getter at which point they are cached here |
| */ |
| gchar *id; |
| gchar *name; |
| gchar *executable; |
| gchar *filename; |
| GIcon *icon; |
| }; |
| |
| G_DEFINE_TYPE_WITH_CODE (GOsxAppInfo, g_osx_app_info, G_TYPE_OBJECT, |
| G_IMPLEMENT_INTERFACE (G_TYPE_APP_INFO, g_osx_app_info_iface_init)) |
| |
| static GOsxAppInfo * |
| g_osx_app_info_new (NSBundle *bundle) |
| { |
| GOsxAppInfo *info = g_object_new (G_TYPE_OSX_APP_INFO, NULL); |
| |
| info->bundle = [bundle retain]; |
| |
| return info; |
| } |
| |
| static void |
| g_osx_app_info_init (GOsxAppInfo *info) |
| { |
| } |
| |
| static void |
| g_osx_app_info_finalize (GObject *object) |
| { |
| GOsxAppInfo *info = G_OSX_APP_INFO (object); |
| |
| g_free (info->id); |
| g_free (info->name); |
| g_free (info->executable); |
| g_free (info->filename); |
| g_clear_object (&info->icon); |
| |
| [info->bundle release]; |
| |
| G_OBJECT_CLASS (g_osx_app_info_parent_class)->finalize (object); |
| } |
| |
| static void |
| g_osx_app_info_class_init (GOsxAppInfoClass *klass) |
| { |
| GObjectClass *gobject_class = G_OBJECT_CLASS (klass); |
| |
| gobject_class->finalize = g_osx_app_info_finalize; |
| } |
| |
| static GAppInfo * |
| g_osx_app_info_dup (GAppInfo *appinfo) |
| { |
| GOsxAppInfo *info; |
| GOsxAppInfo *new_info; |
| |
| g_return_val_if_fail (appinfo != NULL, NULL); |
| |
| info = G_OSX_APP_INFO (appinfo); |
| new_info = g_osx_app_info_new ([info->bundle retain]); |
| |
| return G_APP_INFO (new_info); |
| } |
| |
| static gboolean |
| g_osx_app_info_equal (GAppInfo *appinfo1, |
| GAppInfo *appinfo2) |
| { |
| const gchar *str1, *str2; |
| |
| g_return_val_if_fail (appinfo1 != NULL, FALSE); |
| g_return_val_if_fail (appinfo2 != NULL, FALSE); |
| |
| str1 = g_osx_app_info_get_id (appinfo1); |
| str2 = g_osx_app_info_get_id (appinfo2); |
| |
| return (g_strcmp0 (str1, str2) == 0); |
| } |
| |
| /*< internal > |
| * get_bundle_string_value: |
| * @bundle: a #NSBundle |
| * @key: an #NSString key |
| * |
| * Returns a value from a bundles info.plist file. |
| * It will be utf8 encoded and it must be g_free()'d. |
| * |
| */ |
| static gchar * |
| get_bundle_string_value (NSBundle *bundle, |
| NSString *key) |
| { |
| NSString *value; |
| const gchar *cvalue; |
| gchar *ret; |
| |
| g_return_val_if_fail (bundle != NULL, NULL); |
| |
| value = (NSString *)[bundle objectForInfoDictionaryKey: key]; |
| if (!value) |
| return NULL; |
| |
| cvalue = [value cStringUsingEncoding: NSUTF8StringEncoding]; |
| ret = g_strdup (cvalue); |
| |
| return ret; |
| } |
| |
| static CFStringRef |
| create_cfstring_from_cstr (const gchar *cstr) |
| { |
| return CFStringCreateWithCString (NULL, cstr, kCFStringEncodingUTF8); |
| } |
| |
| #ifdef G_ENABLE_DEBUG |
| static gchar * |
| create_cstr_from_cfstring (CFStringRef str) |
| { |
| g_return_val_if_fail (str != NULL, NULL); |
| |
| CFIndex length = CFStringGetLength (str); |
| CFIndex maxlen = CFStringGetMaximumSizeForEncoding (length, kCFStringEncodingUTF8); |
| gchar *buffer = g_malloc (maxlen + 1); |
| Boolean success = CFStringGetCString (str, (char *) buffer, maxlen, |
| kCFStringEncodingUTF8); |
| if (success) |
| return buffer; |
| else |
| { |
| g_free (buffer); |
| return NULL; |
| } |
| } |
| #endif |
| |
| static char * |
| url_escape_hostname (const char *url) |
| { |
| char *host_start, *ret; |
| |
| host_start = strstr (url, "://"); |
| if (host_start != NULL) |
| { |
| char *host_end, *scheme, *host, *hostname; |
| |
| scheme = g_strndup (url, host_start - url); |
| host_start += 3; |
| host_end = strchr (host_start, '/'); |
| |
| if (host_end != NULL) |
| host = g_strndup (host_start, host_end - host_start); |
| else |
| host = g_strdup (host_start); |
| |
| hostname = g_hostname_to_ascii (host); |
| |
| ret = g_strconcat (scheme, "://", hostname, host_end, NULL); |
| |
| g_free (scheme); |
| g_free (host); |
| g_free (hostname); |
| |
| return ret; |
| } |
| |
| return g_strdup (url); |
| } |
| |
| static CFURLRef |
| create_url_from_cstr (gchar *cstr, |
| gboolean is_file) |
| { |
| gchar *puny_cstr; |
| CFStringRef str; |
| CFURLRef url; |
| |
| puny_cstr = url_escape_hostname (cstr); |
| str = CFStringCreateWithCString (NULL, puny_cstr ? puny_cstr : cstr, kCFStringEncodingUTF8); |
| |
| if (is_file) |
| url = CFURLCreateWithFileSystemPath (NULL, str, kCFURLPOSIXPathStyle, FALSE); |
| else |
| url = CFURLCreateWithString (NULL, str, NULL); |
| |
| if (!url) |
| g_debug ("Creating CFURL from %s %s failed!", cstr, is_file ? "file" : "uri"); |
| |
| g_free (puny_cstr); |
| CFRelease(str); |
| return url; |
| } |
| |
| static CFArrayRef |
| create_url_list_from_glist (GList *uris, |
| gboolean are_files) |
| { |
| GList *lst; |
| int len = g_list_length (uris); |
| CFMutableArrayRef array; |
| |
| if (!len) |
| return NULL; |
| |
| array = CFArrayCreateMutable (NULL, len, &kCFTypeArrayCallBacks); |
| if (!array) |
| return NULL; |
| |
| for (lst = uris; lst != NULL && lst->data; lst = lst->next) |
| { |
| CFURLRef url = create_url_from_cstr ((char*)lst->data, are_files); |
| if (url) |
| CFArrayAppendValue (array, url); |
| } |
| |
| return (CFArrayRef)array; |
| } |
| |
| static LSLaunchURLSpec * |
| create_urlspec_for_appinfo (GOsxAppInfo *info, |
| GList *uris, |
| gboolean are_files) |
| { |
| LSLaunchURLSpec *urlspec = g_new0 (LSLaunchURLSpec, 1); |
| gchar *app_cstr = g_osx_app_info_get_filename (info); |
| |
| /* Strip file:// from app url but ensure filesystem url */ |
| urlspec->appURL = create_url_from_cstr (app_cstr + 7, TRUE); |
| urlspec->launchFlags = kLSLaunchDefaults; |
| urlspec->itemURLs = create_url_list_from_glist (uris, are_files); |
| |
| return urlspec; |
| } |
| |
| static void |
| free_urlspec (LSLaunchURLSpec *urlspec) |
| { |
| if (urlspec->itemURLs) |
| { |
| CFArrayRemoveAllValues ((CFMutableArrayRef)urlspec->itemURLs); |
| CFRelease (urlspec->itemURLs); |
| } |
| CFRelease (urlspec->appURL); |
| g_free (urlspec); |
| } |
| |
| static NSBundle * |
| get_bundle_for_url (CFURLRef app_url) |
| { |
| NSBundle *bundle = [NSBundle bundleWithURL: (NSURL*)app_url]; |
| |
| if (!bundle) |
| { |
| g_debug ("Bundle not found for url."); |
| return NULL; |
| } |
| |
| return bundle; |
| } |
| |
| static NSBundle * |
| get_bundle_for_id (CFStringRef bundle_id) |
| { |
| CFURLRef app_url; |
| NSBundle *bundle; |
| |
| #ifdef AVAILABLE_MAC_OS_X_VERSION_10_10_AND_LATER |
| CFArrayRef urls = LSCopyApplicationURLsForBundleIdentifier (bundle_id, NULL); |
| if (urls) |
| { |
| /* TODO: if there's multiple, we should perhaps prefer one thats in $HOME, |
| * instead of just always picking the first. |
| */ |
| app_url = CFArrayGetValueAtIndex (urls, 0); |
| CFRetain (app_url); |
| CFRelease (urls); |
| } |
| else |
| #else |
| if (LSFindApplicationForInfo (kLSUnknownCreator, bundle_id, NULL, NULL, &app_url) == kLSApplicationNotFoundErr) |
| #endif |
| { |
| #ifdef G_ENABLE_DEBUG /* This can fail often, no reason to alloc strings */ |
| gchar *id_str = create_cstr_from_cfstring (bundle_id); |
| if (id_str) |
| { |
| g_debug ("Application not found for id \"%s\".", id_str); |
| g_free (id_str); |
| } |
| else |
| g_debug ("Application not found for unconvertable bundle id."); |
| #endif |
| return NULL; |
| } |
| |
| bundle = get_bundle_for_url (app_url); |
| CFRelease (app_url); |
| return bundle; |
| } |
| |
| static const char * |
| g_osx_app_info_get_id (GAppInfo *appinfo) |
| { |
| GOsxAppInfo *info = G_OSX_APP_INFO (appinfo); |
| |
| if (!info->id) |
| info->id = get_bundle_string_value (info->bundle, @"CFBundleIdentifier"); |
| |
| return info->id; |
| } |
| |
| static const char * |
| g_osx_app_info_get_name (GAppInfo *appinfo) |
| { |
| GOsxAppInfo *info = G_OSX_APP_INFO (appinfo); |
| |
| if (!info->name) |
| info->name = get_bundle_string_value (info->bundle, @"CFBundleName"); |
| |
| return info->name; |
| } |
| |
| static const char * |
| g_osx_app_info_get_display_name (GAppInfo *appinfo) |
| { |
| return g_osx_app_info_get_name (appinfo); |
| } |
| |
| static const char * |
| g_osx_app_info_get_description (GAppInfo *appinfo) |
| { |
| /* Bundles do not contain descriptions */ |
| return NULL; |
| } |
| |
| static const char * |
| g_osx_app_info_get_executable (GAppInfo *appinfo) |
| { |
| GOsxAppInfo *info = G_OSX_APP_INFO (appinfo); |
| |
| if (!info->executable) |
| info->executable = get_bundle_string_value (info->bundle, @"CFBundleExecutable"); |
| |
| return info->executable; |
| } |
| |
| char * |
| g_osx_app_info_get_filename (GOsxAppInfo *info) |
| { |
| g_return_val_if_fail (info != NULL, NULL); |
| |
| if (!info->filename) |
| { |
| info->filename = g_strconcat ("file://", [[info->bundle bundlePath] |
| cStringUsingEncoding: NSUTF8StringEncoding], |
| NULL); |
| } |
| |
| return info->filename; |
| } |
| |
| static const char * |
| g_osx_app_info_get_commandline (GAppInfo *appinfo) |
| { |
| /* There isn't really a command line value */ |
| return NULL; |
| } |
| |
| static GIcon * |
| g_osx_app_info_get_icon (GAppInfo *appinfo) |
| { |
| GOsxAppInfo *info = G_OSX_APP_INFO (appinfo); |
| |
| if (!info->icon) |
| { |
| gchar *icon_name, *app_uri, *icon_uri; |
| GFile *file; |
| |
| icon_name = get_bundle_string_value (info->bundle, @"CFBundleIconFile"); |
| if (!icon_name) |
| return NULL; |
| |
| app_uri = g_osx_app_info_get_filename (info); |
| icon_uri = g_strconcat (app_uri + 7, "/Contents/Resources/", icon_name, |
| g_str_has_suffix (icon_name, ".icns") ? NULL : ".icns", NULL); |
| g_free (icon_name); |
| |
| file = g_file_new_for_path (icon_uri); |
| info->icon = g_file_icon_new (file); |
| g_object_unref (file); |
| g_free (icon_uri); |
| } |
| |
| return info->icon; |
| } |
| |
| static gboolean |
| g_osx_app_info_launch_internal (GAppInfo *appinfo, |
| GList *uris, |
| gboolean are_files, |
| GError **error) |
| { |
| GOsxAppInfo *info = G_OSX_APP_INFO (appinfo); |
| LSLaunchURLSpec *urlspec = create_urlspec_for_appinfo (info, uris, are_files); |
| gint ret, success = TRUE; |
| |
| if ((ret = LSOpenFromURLSpec (urlspec, NULL))) |
| { |
| /* TODO: Better error codes */ |
| g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, |
| "Opening application failed with code %d", ret); |
| success = FALSE; |
| } |
| |
| free_urlspec (urlspec); |
| return success; |
| } |
| |
| static gboolean |
| g_osx_app_info_supports_uris (GAppInfo *appinfo) |
| { |
| return TRUE; |
| } |
| |
| static gboolean |
| g_osx_app_info_supports_files (GAppInfo *appinfo) |
| { |
| return TRUE; |
| } |
| |
| static gboolean |
| g_osx_app_info_launch (GAppInfo *appinfo, |
| GList *files, |
| GAppLaunchContext *launch_context, |
| GError **error) |
| { |
| return g_osx_app_info_launch_internal (appinfo, files, TRUE, error); |
| } |
| |
| static gboolean |
| g_osx_app_info_launch_uris (GAppInfo *appinfo, |
| GList *uris, |
| GAppLaunchContext *launch_context, |
| GError **error) |
| { |
| return g_osx_app_info_launch_internal (appinfo, uris, FALSE, error); |
| } |
| |
| static gboolean |
| g_osx_app_info_should_show (GAppInfo *appinfo) |
| { |
| /* Bundles don't have hidden attribute */ |
| return TRUE; |
| } |
| |
| static gboolean |
| g_osx_app_info_set_as_default_for_type (GAppInfo *appinfo, |
| const char *content_type, |
| GError **error) |
| { |
| return FALSE; |
| } |
| |
| static const char ** |
| g_osx_app_info_get_supported_types (GAppInfo *appinfo) |
| { |
| /* TODO: get CFBundleDocumentTypes */ |
| return NULL; |
| } |
| |
| static gboolean |
| g_osx_app_info_set_as_last_used_for_type (GAppInfo *appinfo, |
| const char *content_type, |
| GError **error) |
| { |
| /* Not supported. */ |
| return FALSE; |
| } |
| |
| static gboolean |
| g_osx_app_info_can_delete (GAppInfo *appinfo) |
| { |
| return FALSE; |
| } |
| |
| static void |
| g_osx_app_info_iface_init (GAppInfoIface *iface) |
| { |
| iface->dup = g_osx_app_info_dup; |
| iface->equal = g_osx_app_info_equal; |
| |
| iface->get_id = g_osx_app_info_get_id; |
| iface->get_name = g_osx_app_info_get_name; |
| iface->get_display_name = g_osx_app_info_get_display_name; |
| iface->get_description = g_osx_app_info_get_description; |
| iface->get_executable = g_osx_app_info_get_executable; |
| iface->get_commandline = g_osx_app_info_get_commandline; |
| iface->get_icon = g_osx_app_info_get_icon; |
| iface->get_supported_types = g_osx_app_info_get_supported_types; |
| |
| iface->set_as_last_used_for_type = g_osx_app_info_set_as_last_used_for_type; |
| iface->set_as_default_for_type = g_osx_app_info_set_as_default_for_type; |
| |
| iface->launch = g_osx_app_info_launch; |
| iface->launch_uris = g_osx_app_info_launch_uris; |
| |
| iface->supports_uris = g_osx_app_info_supports_uris; |
| iface->supports_files = g_osx_app_info_supports_files; |
| iface->should_show = g_osx_app_info_should_show; |
| iface->can_delete = g_osx_app_info_can_delete; |
| } |
| |
| GAppInfo * |
| g_app_info_create_from_commandline (const char *commandline, |
| const char *application_name, |
| GAppInfoCreateFlags flags, |
| GError **error) |
| { |
| return NULL; |
| } |
| |
| GList * |
| g_osx_app_info_get_all_for_scheme (const char *cscheme) |
| { |
| CFArrayRef bundle_list; |
| CFStringRef scheme; |
| NSBundle *bundle; |
| GList *info_list = NULL; |
| gint i; |
| |
| scheme = create_cfstring_from_cstr (cscheme); |
| bundle_list = LSCopyAllHandlersForURLScheme (scheme); |
| CFRelease (scheme); |
| |
| if (!bundle_list) |
| return NULL; |
| |
| for (i = 0; i < CFArrayGetCount (bundle_list); i++) |
| { |
| CFStringRef bundle_id = CFArrayGetValueAtIndex (bundle_list, i); |
| GAppInfo *info; |
| |
| bundle = get_bundle_for_id (bundle_id); |
| |
| if (!bundle) |
| continue; |
| |
| info = G_APP_INFO (g_osx_app_info_new (bundle)); |
| info_list = g_list_append (info_list, info); |
| } |
| CFRelease (bundle_list); |
| return info_list; |
| } |
| |
| GList * |
| g_app_info_get_all_for_type (const char *content_type) |
| { |
| gchar *mime_type; |
| CFArrayRef bundle_list; |
| CFStringRef type; |
| NSBundle *bundle; |
| GList *info_list = NULL; |
| gint i; |
| |
| mime_type = g_content_type_get_mime_type (content_type); |
| if (g_str_has_prefix (mime_type, "x-scheme-handler/")) |
| { |
| gchar *scheme = strchr (mime_type, '/') + 1; |
| GList *ret = g_osx_app_info_get_all_for_scheme (scheme); |
| |
| g_free (mime_type); |
| return ret; |
| } |
| g_free (mime_type); |
| |
| type = create_cfstring_from_cstr (content_type); |
| bundle_list = LSCopyAllRoleHandlersForContentType (type, kLSRolesAll); |
| CFRelease (type); |
| |
| if (!bundle_list) |
| return NULL; |
| |
| for (i = 0; i < CFArrayGetCount (bundle_list); i++) |
| { |
| CFStringRef bundle_id = CFArrayGetValueAtIndex (bundle_list, i); |
| GAppInfo *info; |
| |
| bundle = get_bundle_for_id (bundle_id); |
| |
| if (!bundle) |
| continue; |
| |
| info = G_APP_INFO (g_osx_app_info_new (bundle)); |
| info_list = g_list_append (info_list, info); |
| } |
| CFRelease (bundle_list); |
| return info_list; |
| } |
| |
| GList * |
| g_app_info_get_recommended_for_type (const char *content_type) |
| { |
| return g_app_info_get_all_for_type (content_type); |
| } |
| |
| GList * |
| g_app_info_get_fallback_for_type (const char *content_type) |
| { |
| return g_app_info_get_all_for_type (content_type); |
| } |
| |
| GAppInfo * |
| g_app_info_get_default_for_type (const char *content_type, |
| gboolean must_support_uris) |
| { |
| gchar *mime_type; |
| CFStringRef type; |
| NSBundle *bundle; |
| #ifdef AVAILABLE_MAC_OS_X_VERSION_10_10_AND_LATER |
| CFURLRef bundle_id; |
| #else |
| CFStringRef bundle_id; |
| #endif |
| |
| mime_type = g_content_type_get_mime_type (content_type); |
| if (g_str_has_prefix (mime_type, "x-scheme-handler/")) |
| { |
| gchar *scheme = strchr (mime_type, '/') + 1; |
| GAppInfo *ret = g_app_info_get_default_for_uri_scheme (scheme); |
| |
| g_free (mime_type); |
| return ret; |
| } |
| g_free (mime_type); |
| |
| type = create_cfstring_from_cstr (content_type); |
| |
| #ifdef AVAILABLE_MAC_OS_X_VERSION_10_10_AND_LATER |
| bundle_id = LSCopyDefaultApplicationURLForContentType (type, kLSRolesAll, NULL); |
| #else |
| bundle_id = LSCopyDefaultRoleHandlerForContentType (type, kLSRolesAll); |
| #endif |
| CFRelease (type); |
| |
| if (!bundle_id) |
| { |
| g_warning ("No default handler found for content type '%s'.", content_type); |
| return NULL; |
| } |
| |
| #ifdef AVAILABLE_MAC_OS_X_VERSION_10_10_AND_LATER |
| bundle = get_bundle_for_url (bundle_id); |
| #else |
| bundle = get_bundle_for_id (bundle_id); |
| #endif |
| CFRelease (bundle_id); |
| |
| if (!bundle) |
| return NULL; |
| |
| return G_APP_INFO (g_osx_app_info_new (bundle)); |
| } |
| |
| GAppInfo * |
| g_app_info_get_default_for_uri_scheme (const char *uri_scheme) |
| { |
| CFStringRef scheme, bundle_id; |
| NSBundle *bundle; |
| |
| scheme = create_cfstring_from_cstr (uri_scheme); |
| bundle_id = LSCopyDefaultHandlerForURLScheme (scheme); |
| CFRelease (scheme); |
| |
| if (!bundle_id) |
| { |
| g_warning ("No default handler found for url scheme '%s'.", uri_scheme); |
| return NULL; |
| } |
| |
| bundle = get_bundle_for_id (bundle_id); |
| CFRelease (bundle_id); |
| |
| if (!bundle) |
| return NULL; |
| |
| return G_APP_INFO (g_osx_app_info_new (bundle)); |
| } |
| |
| GList * |
| g_app_info_get_all (void) |
| { |
| /* There is no API for this afaict |
| * could manually do it... |
| */ |
| return NULL; |
| } |
| |
| void |
| g_app_info_reset_type_associations (const char *content_type) |
| { |
| } |