Comment créer un joli DMG pour Mac OS X à l'aide d'outils de ligne de commande?

J'ai besoin de créer un bon programme d'installation pour une application Mac. Je veux que ce soit une image disque (DMG), avec une taille, une disposition et une image d'arrière-plan prédéfinies.

J'ai besoin de le faire par programmation dans un script, pour être intégré dans un système de build existant (plus un système de pack vraiment, car il ne crée que des installateurs. Les builds se font séparément).

J'ai déjà fait la création DMG en utilisant "hdiutil", ce que je n'ai pas encore découvert, c'est comment faire une disposition d'icônes et spécifier un bitmap d'arrière-plan.

Après beaucoup de recherches, j'ai trouvé cette réponse, et je la mets ici comme réponse à ma propre question, pour référence:

1. Assurez-vous que «Activer l'accès pour les appareils et accessoires fonctionnels» est coché dans Préférences Système >> Accès universel. Il est nécessaire au fonctionnement d'AppleScript. Vous devrez peut-être redémarrer après cette modification (cela ne fonctionne pas autrement sur Mac OS X Server 10.4).

2. Créez un DMG R / W. Il doit être plus grand que le résultat. Dans cet exemple, la variable bash "taille" contient la taille en Ko et le contenu du dossier dans la variable bash "source" sera copié dans le 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. Montez l'image disque et stockez le nom du périphérique (vous voudrez peut-être utiliser la veille pendant quelques secondes après cette opération):

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

4. Stockez l'image d'arrière-plan (au format PNG) dans un dossier appelé ".background" dans le DMG, et stockez son nom dans la variable "backgroundPictureName".

5. Utilisez AppleScript pour définir les styles visuels (le nom de .app doit être dans la variable bash "applicationName", utilisez des variables pour les autres propriétés si nécessaire):

   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. Finalisez le DMG en définissant les autorisations correctement, en le compressant et en le libérant:

   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 
   

Sur Snow Leopard, l'applescript ci-dessus ne définira pas correctement la position de l'icône - il semble que ce soit un bug de Snow Leopard. Une solution de contournement consiste à simplement appeler close / open après avoir défini les icônes, à savoir:

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

Il y a un petit script Bash appelé create-dmg qui construit des DMG de fantaisie avec des arrière-plans personnalisés, un positionnement d'icône personnalisé et un nom de volume.

Je l'ai construit il y a de nombreuses années pour l'entreprise que je dirigeais à l'époque; il survit grâce à la contribution des autres depuis lors, et aurait bien fonctionné.

Il y a aussi node-appdmg qui ressemble à un effort plus moderne et actif basé sur Node.js; vérifiez-le aussi.

N'y allez pas. En tant que développeur Mac à long terme, je peux vous assurer qu'aucune solution ne fonctionne vraiment bien. J'ai essayé tant de solutions, mais elles ne sont pas toutes trop bonnes. Je pense que le problème est qu'Apple ne documente pas vraiment le format des métadonnées pour les données nécessaires.

Voici comment je le fais depuis longtemps, avec beaucoup de succès:

1. Créez un nouveau DMG, inscriptible (!), Assez grand pour contenir les fichiers binaires et supplémentaires attendus comme le fichier lisez-moi (le peu peut fonctionner).

2. Montez le DMG et donnez-lui une mise en page manuellement dans le Finder ou avec les outils qui vous conviennent pour cela (voir le lien FileStorm en bas pour un bon outil). L'image d'arrière-plan est généralement une image que nous mettons dans un dossier caché (".quelque chose") sur le DMG. Mettez-y une copie de votre application (n'importe quelle version, même obsolète, fera l'affaire). Copiez les autres fichiers (alias, readme, etc.) que vous voulez là-bas, encore une fois, les versions obsolètes feront très bien l'affaire. Assurez-vous que les icônes ont les bonnes tailles et positions (IOW, disposez le DMG comme vous le souhaitez).

3. Démontez à nouveau le DMG, tous les paramètres doivent être stockés maintenant.

4. Écrivez un script de création DMG, qui fonctionne comme suit:

   • Il copie le DMG, de sorte que l'original n'est plus jamais touché.
   • Il monte la copie.
   • Il remplace tous les fichiers par les plus récents (par exemple, la dernière application après la construction). Vous pouvez simplement utiliser mv ou idem pour cela en ligne de commande. Notez que lorsque vous remplacez un fichier comme celui-ci, l'icône restera la même, la position restera la même, tout sauf le contenu du fichier (ou répertoire) reste le même (au moins avec idem, que nous utilisons généralement pour cette tâche) . Vous pouvez bien sûr également remplacer l'image d'arrière-plan par une autre (assurez-vous simplement qu'elle a les mêmes dimensions).
   • Après avoir remplacé les fichiers, faites de nouveau démonter la copie DMG par le script.
   • Enfin, appelez hdiutil pour convertir le fichier inscriptible en un fichier DMG compressé (et non inscriptible).

Cette méthode peut ne pas sembler optimale, mais croyez-moi, elle fonctionne très bien en pratique. Vous pouvez placer le DMG d'origine (modèle DMG) même sous contrôle de version (par exemple SVN), donc si vous le changez / détruisez accidentellement, vous pouvez simplement revenir à une révision où il était toujours correct. Vous pouvez ajouter le modèle DMG à votre projet Xcode, ainsi que tous les autres fichiers appartenant au DMG (fichier Lisezmoi, fichier URL, image d'arrière-plan), le tout sous contrôle de version, puis créer une cible (par exemple, une cible externe nommée "Créer DMG") et là, exécutez le script DMG ci-dessus et ajoutez votre ancienne cible principale comme cible dépendante. Vous pouvez accéder aux fichiers dans l'arborescence Xcode en utilisant $ {SRCROOT} dans le script (est toujours la racine source de votre produit) et vous pouvez accéder aux produits de construction en utilisant $ {BUILT_PRODUCTS_DIR} (est toujours le répertoire où Xcode crée les résultats de la construction) .

Résultat: en fait, Xcode peut produire le DMG à la fin de la construction. Un DMG prêt à sortir. Non seulement vous pouvez créer un DMG de relocalisation assez facilement de cette façon, vous pouvez également le faire dans un processus automatisé (sur un serveur sans tête si vous le souhaitez), en utilisant xcodebuild à partir de la ligne de commande (constructions nocturnes automatisées par exemple).

En ce qui concerne la disposition initiale du modèle, FileStorm est un bon outil pour le faire. Il est commercial, mais très puissant et facile à utiliser. La version normale coûte moins de 20 $, elle est donc vraiment abordable. Peut-être que l'on peut automatiser FileStorm pour créer un DMG (par exemple via AppleScript), jamais essayé, mais une fois que vous avez trouvé le modèle DMG parfait, il est vraiment facile de le mettre à jour pour chaque version.

Mettre cette question à jour en fournissant cette réponse.

appdmgest un programme de ligne de commande open source simple, facile à utiliser qui crée des fichiers dmg à partir d'une simple spécification json. Jetez un œil au fichier Lisez-moi sur le site officiel:

https://github.com/LinusU/node-appdmg

Exemple rapide:

1. Installer appdmg

   npm install -g appdmg
   

2. Écrire un fichier 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. Exécuter de programme

   appdmg spec.json test.dmg
   

(Avertissement. Je suis le créateur de appdmg)

Pour ceux d'entre vous qui sont intéressés par ce sujet, je dois mentionner comment je crée le DMG:

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

où

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

Mon application, DropDMG , est un moyen facile de créer des images de disque avec des images d'arrière-plan, des dispositions d'icônes, des icônes de volume personnalisées et des accords de licence logicielle. Il peut être contrôlé à partir d'un système de génération via l'outil de ligne de commande "dropdmg" ou AppleScript. Si vous le souhaitez, les fichiers image et licence RTF peuvent être stockés sous votre système de contrôle de version.

J'ai trouvé cette excellente application mac pour automatiser le processus - http://www.araelium.com/dmgcanvas/ vous devez jeter un œil si vous créez le programme d'installation de dmg pour votre application mac

Pour créer un joli DMG, vous pouvez maintenant simplement utiliser des sources ouvertes bien écrites:

• create-dmg
• node-appdmg
• dmgbuild

Si vous souhaitez définir une icône de volume personnalisée, utilisez la commande ci-dessous

/*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

Maintenant, créez lecture / écriture dmg

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

J'ai finalement obtenu ce travail dans mon propre projet (qui se trouve être dans Xcode). L'ajout de ces 3 scripts à votre phase de construction créera automatiquement une image disque pour votre produit qui est agréable et soignée. Tout ce que vous avez à faire est de construire votre projet et le DMG attendra dans votre dossier produits.

Script 1 (Créer une image disque temporaire):

#!/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 (Définir le script des propriétés de la fenêtre):

#!/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 mesure ci-dessus pour le travail de la fenêtre pour mon projet en particulier en raison de la taille de ma résolution d'arrière-plan et de l'icône; vous devrez peut-être modifier ces valeurs pour votre propre projet.

Script 3 (Créer un script d'image disque final):

#!/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"

Assurez-vous que les fichiers image que vous utilisez se trouvent dans le répertoire $ PROJECT_DIR / $ PROJECT_NAME /!

Les fichiers .DS_Store stockent les paramètres de Windows dans Mac. Les paramètres de Windows incluent la disposition des icônes, l'arrière-plan de la fenêtre, la taille de la fenêtre, etc. Le fichier .DS_Store est nécessaire pour créer la fenêtre des images montées afin de conserver la disposition des fichiers et l'arrière-plan des fenêtres.

Une fois le fichier .DS_Store créé, vous pouvez simplement le copier dans votre programme d'installation créé (DMG).

J'ai également besoin d'utiliser l'approche en ligne de commande pour faire le packaging et la création de dmg "par programmation dans un script". La meilleure réponse que j'ai trouvée jusqu'à présent provient du cadre de création de versions du projet Adium (voir R1). Il existe un script personnalisé (AdiumApplescriptRunner) pour vous permettre d'éviter l'interaction avec l'interface graphique OSX WindowsServer. L'approche "osascript applescript.scpt" nécessite que vous vous connectiez en tant que générateur et exécutez la création dmg à partir d'une session vt100 en ligne de commande.

Le système de gestion des packages OSX n'est pas si avancé par rapport aux autres Unixen qui peuvent effectuer cette tâche facilement et systématiquement.

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

Je viens d'écrire un nouvel utilitaire de ligne de commande (convivial) pour ce faire. Il ne repose pas sur Finder / AppleScript, ni sur aucune des API (obsolètes) d'Alias ​​Manager, et il est facile à configurer et à utiliser.

Quoi qu'il en soit, toute personne intéressée peut le trouver sur PyPi ; la documentation est disponible sur Read The Docs .

Ces réponses sont beaucoup trop compliquées et les temps ont changé. Ce qui suit fonctionne très bien sur 10.9, les autorisations sont correctes et cela a l'air bien.

Créer un DMG en lecture seule à partir d'un répertoire

#!/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

Créer un DMG en lecture seule avec une icône (type .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 autre chose doit se produire, la chose la plus simple consiste à faire une copie temporaire du SRC_DIR et à y apporter des modifications avant de créer un DMG.