macos - quitar - problema java jdk mac

¿Cómo creo un DMG atractivo para Mac OS X usando herramientas de línea de comandos?

Question

Necesito crear un instalador agradable para una aplicación de Mac. Quiero que sea una imagen de disco (DMG), con un tamaño, diseño e imagen de fondo predefinidos.

Necesito hacer esto mediante programación en una secuencia de comandos, para integrarme en un sistema de compilación existente (en realidad es más como un sistema de paquetes, ya que solo crea instaladores. Las compilaciones se realizan por separado).

Ya tengo la creación de DMG usando "hdiutil", lo que no he descubierto aún es cómo hacer un diseño de icono y especificar un mapa de bits de fondo.

Answer 1

Acabo de escribir una nueva utilidad de línea de comandos (amigable) para hacer esto. No se basa en Finder / AppleScript ni en ninguna de las API de Alias ​​Manager (en desuso), y es fácil de configurar y usar.

De todos modos, cualquier persona interesada puede dmgbuild ; La documentación está disponible en Leer los documentos .

Answer 2

Actualizar esta pregunta proporcionando esta respuesta.

appdmg es un programa de línea de comandos de código abierto simple y fácil de usar que crea archivos dmg a partir de una simple especificación json. Eche un vistazo al archivo readme en el sitio web oficial:

github.com/LinusU/node-appdmg

Ejemplo rápido:

1. Instalar appdmg

   npm install -g appdmg

2. Escribe un archivo json ( spec.json )

   {
     "title": "Test Title",
     "background": "background.png",
     "icon-size": 80,
     "contents": [
       { "x": 192, "y": 344, "type": "file", "path": "TestApp.app" },
       { "x": 448, "y": 344, "type": "link", "path": "/Applications" }
     ]
   }

3. Ejecute el programa

   appdmg spec.json test.dmg

(descargo de responsabilidad. Soy el creador de appdmg)

Answer 3

Después de mucha investigación, se me ocurrió esta respuesta y, por este medio, la pongo aquí como respuesta a mi propia pregunta, para referencia:

1. Asegúrese de que la opción "Activar acceso para dispositivos de asistencia" esté marcada en Preferencias del sistema >> Acceso universal. Se requiere para que funcione AppleScript. Es posible que tenga que reiniciar después de este cambio (no funciona de otra manera en Mac OS X Server 10.4).

2. Crear un R / W DMG. Debe ser más grande de lo que será el resultado. En este ejemplo, la variable de bash "tamaño" contiene el tamaño en Kb y el contenido de la carpeta en la variable de bash de "fuente" se copiará en el DMG:

   hdiutil create -srcfolder "${source}" -volname "${title}" -fs HFS+ /
         -fsargs "-c c=64,a=16,e=16" -format UDRW -size ${size}k pack.temp.dmg

3. Monte la imagen del disco y almacene el nombre del dispositivo (es posible que desee usar la suspensión durante unos segundos después de esta operación):

   device=$(hdiutil attach -readwrite -noverify -noautoopen "pack.temp.dmg" | /
            egrep ''^/dev/'' | sed 1q | awk ''{print $1}'')

4. Almacene la imagen de fondo (en formato PNG) en una carpeta llamada ".background" en el DMG, y almacene su nombre en la variable "backgroundPictureName".

5. Use AppleScript para establecer los estilos visuales (el nombre de .app debe estar en la variable bash "applicationName", use variables para las otras propiedades según sea necesario):

   echo ''
      tell application "Finder"
        tell disk "''${title}''"
              open
              set current view of container window to icon view
              set toolbar visible of container window to false
              set statusbar visible of container window to false
              set the bounds of container window to {400, 100, 885, 430}
              set theViewOptions to the icon view options of container window
              set arrangement of theViewOptions to not arranged
              set icon size of theViewOptions to 72
              set background picture of theViewOptions to file ".background:''${backgroundPictureName}''"
              make new alias file at container window to POSIX file "/Applications" with properties {name:"Applications"}
              set position of item "''${applicationName}''" of container window to {100, 100}
              set position of item "Applications" of container window to {375, 100}
              update without registering applications
              delay 5
              close
        end tell
      end tell
   '' | osascript

6. Finalice el DMG configurando los permisos correctamente, comprimiéndolos y liberándolos:

   chmod -Rf go-w /Volumes/"${title}"
   sync
   sync
   hdiutil detach ${device}
   hdiutil convert "/pack.temp.dmg" -format UDZO -imagekey zlib-level=9 -o "${finalDMGName}"
   rm -f /pack.temp.dmg 

En Snow Leopard, el ejemplo anterior no establecerá la posición del ícono correctamente, parece ser un error de Snow Leopard. Una solución es simplemente cerrar / abrir después de configurar los iconos, es decir:

..
set position of item "''${applicationName}''" of container window to {100, 100}
set position of item "Applications" of container window to {375, 100}
close
open

Answer 4

Encontré esta gran aplicación para mac para automatizar el proceso: http://www.araelium.com/dmgcanvas/ debe tener un vistazo si está creando el instalador dmg para su aplicación mac

Answer 5

Estas respuestas son demasiado complicadas y los tiempos han cambiado. Lo siguiente funciona bien en 10.9, los permisos son correctos y se ve bien.

Crear un DMG de solo lectura desde un directorio

#!/bin/sh
# create_dmg Frobulator Frobulator.dmg path/to/frobulator/dir [ ''Your Code Sign Identity'' ]
set -e

VOLNAME="$1"
DMG="$2"
SRC_DIR="$3"
CODESIGN_IDENTITY="$4"

hdiutil create -srcfolder "$SRC_DIR" /
  -volname "$VOLNAME" /
  -fs HFS+ -fsargs "-c c=64,a=16,e=16" /
  -format UDZO -imagekey zlib-level=9 "$DMG"

if [ -n "$CODESIGN_IDENTITY" ]; then
  codesign -s "$CODESIGN_IDENTITY" -v "$DMG"
fi

Cree DMG de solo lectura con un icono (tipo .icns)

#!/bin/sh
# create_dmg_with_icon Frobulator Frobulator.dmg path/to/frobulator/dir path/to/someicon.icns [ ''Your Code Sign Identity'' ]
set -e
VOLNAME="$1"
DMG="$2"
SRC_DIR="$3"
ICON_FILE="$4"
CODESIGN_IDENTITY="$5"

TMP_DMG="$(mktemp -u -t XXXXXXX)"
trap ''RESULT=$?; rm -f "$TMP_DMG"; exit $RESULT'' INT QUIT TERM EXIT
hdiutil create -srcfolder "$SRC_DIR" -volname "$VOLNAME" -fs HFS+ /
               -fsargs "-c c=64,a=16,e=16" -format UDRW "$TMP_DMG"
TMP_DMG="${TMP_DMG}.dmg" # because OSX appends .dmg
DEVICE="$(hdiutil attach -readwrite -noautoopen "$TMP_DMG" | awk ''NR==1{print$1}'')"
VOLUME="$(mount | grep "$DEVICE" | sed ''s/^[^ ]* on //;s/ ([^)]*)$//'')"
# start of DMG changes
cp "$ICON_FILE" "$VOLUME/.VolumeIcon.icns"
SetFile -c icnC "$VOLUME/.VolumeIcon.icns"
SetFile -a C "$VOLUME"
# end of DMG changes
hdiutil detach "$DEVICE"
hdiutil convert "$TMP_DMG" -format UDZO -imagekey zlib-level=9 -o "$DMG"
if [ -n "$CODESIGN_IDENTITY" ]; then
  codesign -s "$CODESIGN_IDENTITY" -v "$DMG"
fi

Si es necesario que ocurra algo más, lo más fácil es hacer una copia temporal del SRC_DIR y aplicar cambios antes de crear un DMG.

Answer 6

Finalmente conseguí esto trabajando en mi propio proyecto (que está en Xcode). Agregar estos 3 scripts a su fase de compilación creará automáticamente una Imagen de Disco para su producto que es agradable y ordenada. Todo lo que tiene que hacer es construir su proyecto y el DMG estará esperando en su carpeta de productos.

Script 1 (Crear imagen de disco temporal):

#!/bin/bash
#Create a R/W DMG

dir="$TEMP_FILES_DIR/disk"
dmg="$BUILT_PRODUCTS_DIR/$PRODUCT_NAME.temp.dmg"

rm -rf "$dir"
mkdir "$dir"
cp -R "$BUILT_PRODUCTS_DIR/$PRODUCT_NAME.app" "$dir"
ln -s "/Applications" "$dir/Applications"
mkdir "$dir/.background"
cp "$PROJECT_DIR/$PROJECT_NAME/some_image.png" "$dir/.background"
rm -f "$dmg"
hdiutil create "$dmg" -srcfolder "$dir" -volname "$PRODUCT_NAME" -format UDRW

#Mount the disk image, and store the device name
hdiutil attach "$dmg" -noverify -noautoopen -readwrite

Script 2 (Establecer Script de Propiedades de Ventana):

#!/usr/bin/osascript
#get the dimensions of the main window using a bash script

set {width, height, scale} to words of (do shell script "system_profiler SPDisplaysDataType | awk ''/Main Display: Yes/{found=1} /Resolution/{width=$2; height=$4} /Retina/{scale=($2 == /"Yes/" ? 2 : 1)} /^ {8}[^ ]+/{if(found) {exit}; scale=1} END{printf /"%d %d %d//n/", width, height, scale}''")
set x to ((width / 2) / scale)
set y to ((height / 2) / scale)

#get the product name using a bash script
set {product_name} to words of (do shell script "printf /"%s/", $PRODUCT_NAME")
set background to alias ("Volumes:"&product_name&":.background:some_image.png")

tell application "Finder"
    tell disk product_name
        open
        set current view of container window to icon view
        set toolbar visible of container window to false
        set statusbar visible of container window to false
        set the bounds of container window to {x, y, (x + 479), (y + 383)}
        set theViewOptions to the icon view options of container window
        set arrangement of theViewOptions to not arranged
        set icon size of theViewOptions to 128
        set background picture of theViewOptions to background
        set position of item (product_name & ".app") of container window to {100, 225}
        set position of item "Applications" of container window to {375, 225}
        update without registering applications
        close
    end tell
end tell

La medida anterior para el trabajo de la ventana para mi proyecto específicamente debido al tamaño de mi imagen de fondo y resolución de iconos; Es posible que necesite modificar estos valores para su propio proyecto.

Script 3 (Make Script Final de Imagen de Disco):

#!/bin/bash
dir="$TEMP_FILES_DIR/disk"
cp "$PROJECT_DIR/$PROJECT_NAME/some_other_image.png" "$dir/"

#unmount the temp image file, then convert it to final image file
sync
sync
hdiutil detach /Volumes/$PRODUCT_NAME
rm -f "$BUILT_PRODUCTS_DIR/$PRODUCT_NAME.dmg"
hdiutil convert "$BUILT_PRODUCTS_DIR/$PRODUCT_NAME.temp.dmg" -format UDZO -imagekey zlib-level=9 -o "$BUILT_PRODUCTS_DIR/$PRODUCT_NAME.dmg"
rm -f "$BUILT_PRODUCTS_DIR/$PRODUCT_NAME.temp.dmg"

#Change the icon of the image file
sips -i "$dir/some_other_image.png"
DeRez -only icns "$dir/some_other_image.png" > "$dir/tmpicns.rsrc"
Rez -append "$dir/tmpicns.rsrc" -o "$BUILT_PRODUCTS_DIR/$PRODUCT_NAME.dmg"
SetFile -a C "$BUILT_PRODUCTS_DIR/$PRODUCT_NAME.dmg"

rm -rf "$dir"

¡Asegúrese de que los archivos de imagen que está utilizando estén en el directorio $ PROJECT_DIR / $ PROJECT_NAME /!

Answer 7

Hay un pequeño script de Bash llamado create-dmg que crea DMG sofisticados con fondos personalizados, posicionamiento de iconos personalizados y nombre de volumen.

Lo construí hace muchos años para la compañía que dirigí en ese momento; sobrevive en la contribución de otras personas desde entonces y, según se informa, funciona bien.

También hay github.com/LinusU/node-appdmg que parece un esfuerzo más moderno y activo basado en Node.js; échale un vistazo también.

Answer 8

Los archivos .DS_Store almacenan la configuración de Windows en Mac. La configuración de Windows incluye el diseño de los iconos, el fondo de la ventana, el tamaño de la ventana, etc. El archivo .DS_Store es necesario para crear la ventana para imágenes montadas para preservar la disposición de los archivos y el fondo de las ventanas.

Una vez que haya creado el archivo .DS_Store, puede copiarlo en su instalador creado (DMG).

Answer 9

Mi aplicación, DropDMG , es una manera fácil de crear imágenes de disco con imágenes de fondo, diseños de iconos, iconos de volumen personalizados y acuerdos de licencia de software. Se puede controlar desde un sistema de compilación a través de la herramienta de línea de comandos "dropdmg" o AppleScript. Si lo desea, los archivos RTF de imagen y licencia se pueden almacenar bajo su sistema de control de versiones.

Answer 10

No vayas alli Como desarrollador de Mac a largo plazo, puedo asegurarle que ninguna solución funciona realmente bien. Probé muchas soluciones, pero no todas son demasiado buenas. Creo que el problema es que Apple no documenta realmente el formato de metadatos para los datos necesarios.

Así es como lo estoy haciendo durante mucho tiempo, con mucho éxito:

1. Cree un nuevo DMG, escribible (!), Lo suficientemente grande como para contener el binario esperado y los archivos adicionales como el archivo Léame (es posible que funcione de forma dispersa).

2. Monta el DMG y dale un diseño manualmente en Finder o con las herramientas que te convengan para hacerlo (consulta el enlace FileStorm en la parte inferior para obtener una buena herramienta). La imagen de fondo suele ser una imagen que colocamos en una carpeta oculta (".something") en el DMG. Coloque una copia de su aplicación allí (cualquier versión, incluso una desactualizada, servirá). Copie otros archivos (alias, léame, etc.) que desee, una vez más, las versiones desactualizadas funcionarán bien. Asegúrese de que los iconos tengan los tamaños y las posiciones correctas (IOW, distribuya el DMG de la forma que desee).

3. Desmonte el DMG de nuevo, todas las configuraciones ya deberían estar almacenadas.

4. Escribe un script de creación de DMG, que funciona de la siguiente manera:

   • Copia el DMG, por lo que el original no se vuelve a tocar.
   • Se monta la copia.
   • Reemplaza todos los archivos con los más actualizados (por ejemplo, la última aplicación después de la compilación). Simplemente puede usar mv o ídem para eso en la línea de comandos. Tenga en cuenta que cuando reemplace un archivo como ese, el ícono permanecerá igual, la posición permanecerá igual, todo excepto el contenido del archivo (o directorio) permanecerá igual (al menos con ídem, que usualmente usamos para esa tarea) . Por supuesto, también puede reemplazar la imagen de fondo por otra (solo asegúrese de que tenga las mismas dimensiones).
   • Después de reemplazar los archivos, haga que el script desmonte la copia DMG nuevamente.
   • Finalmente, llame a hdiutil para convertir el DMG comprimible, a un DMG comprimido (y no grabable).

Este método puede no parecer óptimo, pero confía en mí, funciona muy bien en la práctica. Puede colocar el DMG original (plantilla DMG) incluso bajo el control de versión (por ejemplo, SVN), por lo que si alguna vez lo cambia / destruye accidentalmente, puede volver a una revisión en la que aún estaba bien. Puede agregar la plantilla DMG a su proyecto Xcode, junto con todos los demás archivos que pertenecen a DMG (readme, URL file, background image), todo bajo el control de versión y luego crear un objetivo (por ejemplo, un objetivo externo llamado "Crear DMG") y allí ejecute el script DMG de arriba y agregue su antiguo objetivo principal como objetivo dependiente. Puede acceder a los archivos en el árbol de Xcode usando $ {SRCROOT} en el script (siempre es la raíz de origen de su producto) y puede acceder a los productos de compilación usando $ {BUILT_PRODUCTS_DIR} (es siempre el directorio donde Xcode crea los resultados de la compilación) .

Resultado: En realidad, Xcode puede producir el DMG al final de la compilación. Un DMG que está listo para su lanzamiento. De esta forma, no solo puede crear un DMG de reenvío, sino que también puede hacerlo en un proceso automatizado (en un servidor sin cabeza si lo desea), utilizando xcodebuild desde la línea de comandos (compilaciones nocturnas automatizadas, por ejemplo).

Con respecto al diseño inicial de la plantilla, FileStorm es una buena herramienta para hacerlo. Es comercial, pero muy potente y fácil de usar. La versión normal es menos de $ 20, por lo que es realmente asequible. Tal vez uno pueda automatizar FileStorm para crear un DMG (por ejemplo, a través de AppleScript), nunca lo intentó, pero una vez que ha encontrado la plantilla perfecta de DMG, es realmente fácil de actualizar para cada versión.

Answer 11

Para aquellos de ustedes que estén interesados ​​en este tema, debo mencionar cómo creo el DMG:

hdiutil create XXX.dmg -volname "YYY" -fs HFS+ -srcfolder "ZZZ"

dónde

XXX == disk image file name (duh!)
YYY == window title displayed when DMG is opened
ZZZ == Path to a folder containing the files that will be copied into the DMG

Answer 12

Para crear un DMG atractivo, ahora solo puede usar algunas fuentes abiertas bien escritas:

• create-dmg
• github.com/LinusU/node-appdmg
• dmgbuild

Answer 13

Si desea configurar un ícono de volumen personalizado, use el siguiente comando

/*Add a drive icon*/
cp "/Volumes/customIcon.icns" "/Volumes/dmgName/.VolumeIcon.icns"  


/*SetFile -c icnC will change the creator of the file to icnC*/
SetFile -c icnC /<your path>/.VolumeIcon.icns

Ahora crea dmg de lectura / escritura

/*to set custom icon attribute*/
SetFile -a C /Volumes/dmgName

Answer 14

También necesito utilizar el enfoque de línea de comandos para realizar el empaquetado y la creación de dmg "programáticamente en un script". La mejor respuesta que encontré hasta ahora es del marco de creación de la versión del proyecto Adium (ver R1). Existe un script personalizado (AdiumApplescriptRunner) para permitirle evitar la interacción de la GUI de OSX WindowsServer. El enfoque "osascript applescript.scpt" requiere que inicie sesión como constructor y ejecute la creación dmg desde una sesión de línea de comandos vt100.

El sistema de administración de paquetes OSX no es tan avanzado en comparación con otros Unixen que pueden hacer esta tarea de manera fácil y sistemática.

R1: http://hg.adium.im/adium-1.4/file/00d944a3ef16/Release