Jak stworzyć ładnie wyglądający DMG dla Mac OS X za pomocą narzędzi wiersza poleceń?

Muszę stworzyć fajny instalator dla aplikacji Mac. Chcę, aby był to obraz dysku (DMG) o zdefiniowanym rozmiarze, układzie i obrazie tła.

Muszę to zrobić programowo w skrypcie, aby zintegrować go z istniejącym systemem kompilacji (tak naprawdę to system paczek, ponieważ tworzy tylko instalatory. Kompilacje są wykonywane osobno).

Mam już tworzenie DMG przy użyciu „hdiutil”, czego jeszcze nie dowiedziałem się, jak utworzyć układ ikon i określić bitmapę w tle.

Po wielu badaniach wymyśliłem tę odpowiedź i niniejszym umieszczam ją tutaj jako odpowiedź na moje własne pytanie w celach informacyjnych:

1. Upewnij się, że „Włącz dostęp dla urządzeń pomocniczych” jest zaznaczone w Preferencjach systemowych >> Universal Access. Wymagany jest do działania AppleScript. Po tej zmianie może być konieczne ponowne uruchomienie komputera (nie działa inaczej w systemie Mac OS X Server 10.4).

2. Utwórz R / W DMG. Musi być większy niż wynik. W tym przykładzie zmienna bash „size” zawiera rozmiar w Kb, a zawartość folderu w zmiennej bash „source” zostanie skopiowana do 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. Zamontuj obraz dysku i zapisz nazwę urządzenia (możesz chcieć użyć trybu uśpienia przez kilka sekund po tej operacji):

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

4. Zapisz obraz tła (w formacie PNG) w folderze o nazwie „.background” w DMG i zapisz jego nazwę w zmiennej „backgroundPictureName”.

5. Użyj AppleScript, aby ustawić style wizualne (nazwa .app musi być w zmiennej bash „applicationName”, w razie potrzeby użyj zmiennych dla innych właściwości):

   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. Sfinalizuj DMG, odpowiednio ustawiając uprawnienia, kompresując je i zwalniając:

   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 
   

W systemie Snow Leopard powyższy skrypt jabłkowy nie ustawi poprawnie pozycji ikony - wydaje się, że jest to błąd w systemie Snow Leopard. Jednym z obejść jest po prostu wywołanie opcji zamknij / otwórz po ustawieniu ikon, tj .:

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

Istnieje mały skrypt Bash o nazwie create-dmg, który tworzy fantazyjne DMG z niestandardowym tłem, niestandardowym pozycjonowaniem ikon i nazwą woluminu.

Zbudowałem go wiele lat temu dla firmy, którą wtedy prowadziłem; od tego czasu przetrwał dzięki wkładowi innych ludzi i podobno działa dobrze.

Istnieje również node-appdmg, który wygląda na bardziej nowoczesny i aktywny wysiłek oparty na Node.js; sprawdź to również.

Nie idź tam. Jako długoterminowy programista Mac, zapewniam cię, że żadne rozwiązanie naprawdę nie działa dobrze. Próbowałem tak wielu rozwiązań, ale nie wszystkie są zbyt dobre. Myślę, że problem polega na tym, że Apple tak naprawdę nie dokumentuje formatu metadanych niezbędnych danych.

Oto jak robię to od dłuższego czasu, bardzo skutecznie:

1. Utwórz nowy plik DMG, zapisywalny (!), Wystarczająco duży, aby pomieścić oczekiwane pliki binarne i dodatkowe, takie jak readme (rzadkie mogą działać).

2. Zamontuj DMG i nadaj mu układ ręcznie w Finderze lub dowolnymi narzędziami, które Ci odpowiadają (dobre narzędzie znajduje się na dole pliku FileStorm). Obraz w tle to zwykle obraz, który umieszczamy w ukrytym folderze („.something”) na DMG. Umieść tam kopię swojej aplikacji (wystarczy dowolna wersja, nawet ta nieaktualna). Skopiuj inne pliki (aliasy, pliki readme itp.), Które chcesz tam, ponownie, przestarzałe wersje będą w porządku. Upewnij się, że ikony mają odpowiednie rozmiary i pozycje (IOW, ustaw DMG tak, jak chcesz).

3. Ponownie odmontuj DMG, wszystkie ustawienia powinny być już zapisane.

4. Napisz skrypt tworzenia DMG, który działa w następujący sposób:

   • Kopiuje DMG, więc oryginalnego nigdy już nie można dotknąć.
   • Montuje kopię.
   • Zastępuje wszystkie pliki najnowszymi (np. Najnowsza aplikacja po kompilacji). Możesz po prostu użyć mv lub ditto do tego w wierszu poleceń. Uwaga: po zastąpieniu takiego pliku ikona pozostanie taka sama, pozycja pozostanie taka sama, wszystko oprócz zawartości pliku (lub katalogu) pozostanie niezmienione (przynajmniej w przypadku tego samego, którego zwykle używamy do tego zadania) . Oczywiście możesz również zastąpić obraz tła innym (upewnij się, że ma takie same wymiary).
   • Po zastąpieniu plików, skrypt ponownie odmontuj kopię DMG.
   • Na koniec wywołaj hdiutil, aby przekonwertować zapisywalny, na skompresowany (i taki nie zapisywalny) DMG.

Ta metoda może nie brzmieć optymalnie, ale zaufaj mi, działa naprawdę dobrze w praktyce. Możesz umieścić oryginalny DMG (szablon DMG) nawet pod kontrolą wersji (np. SVN), więc jeśli kiedykolwiek go przypadkowo zmienisz / zniszczysz, możesz po prostu wrócić do wersji, w której nadal jest w porządku. Możesz dodać szablon DMG do swojego projektu Xcode wraz ze wszystkimi innymi plikami należącymi do DMG (plik readme, plik URL, obraz tła), wszystko pod kontrolą wersji, a następnie utworzyć cel (np. Cel zewnętrzny o nazwie „Utwórz DMG”) i uruchom powyższy skrypt DMG i dodaj swój stary główny cel jako cel zależny. Możesz uzyskać dostęp do plików w drzewie Xcode za pomocą $ {SRCROOT} w skrypcie (zawsze jest to źródłowy katalog główny produktu) i możesz uzyskać dostęp do produktów kompilacji za pomocą $ {BUILT_PRODUCTS_DIR} (zawsze jest to katalog, w którym Xcode tworzy wyniki kompilacji) .

Wynik: w rzeczywistości Xcode może wyprodukować DMG na końcu kompilacji. DMG, który jest gotowy do wydania. W ten sposób możesz nie tylko utworzyć DMG w prosty sposób, ale możesz to zrobić w zautomatyzowanym procesie (na serwerze bezgłowym, jeśli chcesz), używając xcodebuild z wiersza poleceń (na przykład automatyczne kompilacje nocne).

Jeśli chodzi o początkowy układ szablonu, FileStorm jest dobrym narzędziem do tego. Jest komercyjny, ale bardzo wydajny i łatwy w użyciu. Normalna wersja kosztuje mniej niż 20 USD, więc jest naprawdę przystępna cenowo. Być może można zautomatyzować FileStorm, aby utworzyć DMG (np. Za pomocą AppleScript), nigdy tego nie próbowałem, ale kiedy już znajdziesz idealny szablon DMG, naprawdę łatwo jest go zaktualizować dla każdej wersji.

Uaktualnienie tego pytania poprzez udzielenie tej odpowiedzi.

appdmgjest prostym, łatwym w użyciu, otwartym programem wiersza poleceń, który tworzy pliki dmg na podstawie prostej specyfikacji json. Spójrz na plik Readme na oficjalnej stronie:

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

Szybki przykład:

1. Zainstaluj appdmg

   npm install -g appdmg
   

2. Napisz plik 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. Uruchom program

   appdmg spec.json test.dmg
   

(wyłączenie odpowiedzialności. Jestem twórcą appdmg)

Dla tych, którzy są zainteresowani tym tematem, powinienem wspomnieć o tym, jak tworzę DMG:

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

gdzie

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

Moja aplikacja, DropDMG , to łatwy sposób na tworzenie obrazów dysków ze zdjęciami w tle, układami ikon, niestandardowymi ikonami woluminów i umowami licencyjnymi oprogramowania. Można nim sterować z systemu kompilacji za pomocą narzędzia wiersza polecenia „dropdmg” lub AppleScript. W razie potrzeby zdjęcia RTF i pliki licencyjne można zapisać w systemie kontroli wersji.

Znalazłem tę świetną aplikację na komputery Mac do automatyzacji procesu - http://www.araelium.com/dmgcanvas/ musisz sprawdzić, czy tworzysz instalator dmg dla aplikacji na komputer Mac

Aby stworzyć ładnie wyglądający DMG, możesz teraz po prostu użyć dobrze napisanych otwartych źródeł:

• create-dmg
• node-appdmg
• dmgbuild

Jeśli chcesz ustawić niestandardową ikonę głośności, użyj poniższego polecenia

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

Teraz utwórz dmg do odczytu / zapisu

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

W końcu mam to działające w moim własnym projekcie (który akurat jest w Xcode). Dodanie tych 3 skryptów do fazy kompilacji spowoduje automatyczne utworzenie obrazu dysku dla twojego produktu, który jest miły i schludny. Wystarczy zbudować projekt, a DMG będzie czekać w folderze produktów.

Skrypt 1 (Utwórz obraz dysku Temp):

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

Skrypt 2 (Ustaw skrypt właściwości okna):

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

Powyższy pomiar dla okna działa w moim projekcie, szczególnie ze względu na rozmiar mojego obrazu tła i rozdzielczość ikony; może być konieczne zmodyfikowanie tych wartości dla własnego projektu.

Skrypt 3 (Utwórz końcowy skrypt obrazu dysku):

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

Upewnij się, że pliki obrazów, których używasz, znajdują się w katalogu $ PROJECT_DIR / $ PROJECT_NAME /!

Pliki .DS_Store przechowują ustawienia systemu Windows na komputerze Mac. Ustawienia systemu Windows obejmują układ ikon, tło okna, rozmiar okna itp. Plik .DS_Store jest potrzebny do utworzenia okna dla zamontowanych obrazów, aby zachować układ plików i tło okna.

Po utworzeniu pliku .DS_Store możesz go po prostu skopiować do utworzonego instalatora (DMG).

Potrzebuję również zastosowania podejścia z linii poleceń, aby wykonać pakowanie i tworzenie dmg „programowo w skrypcie”. Najlepsza odpowiedź, jaką znalazłem do tej pory, pochodzi z projektu Adium „Framework budowania wersji (patrz R1). Istnieje niestandardowy skrypt (AdiumApplescriptRunner), który pozwala uniknąć interakcji GUI z Windows OS Server. Podejście „osascript applescript.scpt” wymaga zalogowania się jako konstruktor i uruchomienia tworzenia dmg z sesji wiersza polecenia vt100.

System zarządzania pakietami OSX nie jest tak zaawansowany w porównaniu do innych systemów Unixen, które mogą to zadanie łatwo i systematycznie wykonywać.

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

Właśnie napisałem nowe (przyjazne) narzędzie wiersza poleceń, aby to zrobić. Nie opiera się na Finder / AppleScript ani na żadnym (przestarzałym) interfejsie API Alias ​​Manager i jest łatwa w konfiguracji i obsłudze.

W każdym razie każdy zainteresowany może znaleźć go na PyPi ; dokumentacja jest dostępna w Read The Docs .

Te odpowiedzi są zbyt skomplikowane, a czasy się zmieniły. Następujące działa na 10.9 w porządku, uprawnienia są prawidłowe i ładnie to wygląda.

Utwórz DMG tylko do odczytu z katalogu

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

Utwórz DMG tylko do odczytu z ikoną (typ .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

Jeśli coś innego musi się wydarzyć, najłatwiej jest zrobić tymczasową kopię SRC_DIR i zastosować zmiany do niej przed utworzeniem DMG.