Features fir iOS Uwendungen ze bauen an ze liwweren

An dësem Artikel deele mir d'Erfahrung fir d'Versammlung an d'Liwwerung vun iOS Uwendungen un d'Benotzer, déi de Plarium Krasnodar Studio am Prozess vum Debugging CI / CD gesammelt huet.

Virbereedung

All Persoun, déi op eng oder aner Manéier an der Entwécklung vun Applikatiounen fir Apple Apparater involvéiert ass, huet schonn d'kontroversiell Komfort vun der Infrastruktur appréciéiert. Schwieregkeeten ginn iwwerall fonnt: vum Entwécklerprofilmenü bis zum Debug a bauen Tools.

Et gi vill Artikelen iwwer d'"Basis" um Internet, also wäerte mir probéieren den Haapt Saach ze Highlight. Hei ass wat Dir braucht fir Är Applikatioun erfollegräich ze bauen:

• Entwéckler Kont;
• e macOS-baséiert Apparat deen als Build Server handelt;
• generéiert Entwéckler Zertifikat, déi weider benotzt gi fir d'Uwendung z'ënnerschreiwen;
• erstallt Applikatioun mat eenzegaarteg ID (d'Wichtegkeet vum Bundle Identifier sollt bemierkt ginn, well d'Benotzung vun der Wildcard ID et onméiglech mécht vill Funktiounen vun der Applikatioun ze benotzen, zum Beispill: Associated Domains, Push Notifications, Apple Sign In an anerer);
• Profil Applikatioun Ënnerschrëften.

En Entwécklerzertifika muss iwwer Keychain op all MacOS Apparat generéiert ginn. D'Zort vum Zertifika ass ganz wichteg. Ofhängeg vun der Applikatiounsëmfeld (Dev, QA, Staging, Produktioun) wäert et ënnerscheeden (Entwécklung oder Verdeelung), sou wéi d'Zort vun der Applikatioun Ënnerschrëftprofil.

Haaptarten vu Profiler:

• Entwécklung - geduecht fir d'Uwendung vum Entwécklungsteam z'ënnerschreiwen, en Entwécklungszertifika gëtt benotzt (Typ Numm iPhone Entwéckler: XXXXX);
• Ad Hoc - geduecht fir eng Testapplikatioun an intern Verifizéierung vum QA Departement z'ënnerschreiwen, den Entwéckler Verdeelungszertifika gëtt benotzt (Typ Numm iPhone Distribution: XXXXX);
• App Store - Verëffentlechung bauen fir extern Testen iwwer TestFlight an Eroplueden an den App Store, den Entwéckler Verdeelungszertifika gëtt benotzt.

Wann Dir Entwécklung an Ad Hoc Profiler generéiert, gëtt et och uginn Apparat Lëscht, op deem Dir e Build installéiere kënnt, wat Iech erlaabt den Zougang fir Benotzer weider ze beschränken. Et gëtt keng Lëscht vun Apparater am App Store Profil, well Zougangskontroll während zougemaach Beta Testen vun TestFlight gehandhabt gëtt, déi spéider diskutéiert gëtt.

Fir Kloerheet kënnt Dir de Profil vum Entwéckler a Form vun enger Tabell hei ënnen presentéieren. Dëst mécht et méi einfach ze verstoen wat Parameteren mir brauchen fir Assemblée a wou se kréien aus.

Assemblée

Ze maachen et méi einfach Assemblée vun Projet an Ëmwelt ze trennen, mir benotzen Profil Nimm wéi ${ProjectName}_${Instance}, dat ass, Projet Numm + Instanz (hängt vun der Applikatioun Ëmfeld: Dev, QA, GD, Staging, Live, a sou weider).

Wann importéiert op de Build Server, ännert de Profil säin Numm op eng eenzegaarteg ID a gëtt an den Dossier geplënnert /Users/$Username/Library/MobileDevice/Provisioning Profiles (Wou $Username entsprécht dem Benotzerkontnumm vum Build Server).

Et ginn zwou Weeër fir eng *.ipa Datei ze bauen - Legacy (PackageApplication) a modern (iwwer XcAchive Kreatioun an Export). Déi éischt Method gëtt als obsolet ugesinn, well zënter der Versioun 8.3 ass den App-Datei Verpackungsmodul aus der Xcode Verdeelung geläscht. Fir et ze benotzen, musst Dir de Modul vum alen Xcode (Versioun 8.2 a fréier) an den Dossier kopéieren:
/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/usr/bin/

A lafen dann de Kommando:

chmod +x /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/usr/bin/*

Als nächst musst Dir d'*.app Datei vun der Applikatioun sammelen:

xcodebuild 
-workspace $ProjectDir/$ProjectName.xcworkspace 
-scheme $SchemeName 
-sdk iphoneos 
build 
-configuration Release 
-derivedDataPath build 
CODE_SIGN_IDENTITY=”$DevAccName”
PROVISIONING_PROFILE=”$ProfileId”
DEPLOYMENT_POSTPROCESSING=YES 
SKIP_INSTALL=YES 
ENABLE_BITCODE=NO

Wou:

-workspace - Wee op d'Projetdatei.

-scheme - de Schema benotzt, am Projet spezifizéiert.

-derivedDataPath - Wee fir déi gesammelt Applikatioun erofzelueden (*.app).

CODE_SIGN_IDENTITY - den Numm vum Entwécklerkonto, deen am Keychain verifizéiert ka ginn (iPhone Entwéckler: XXXX XXXXXXX, ouni TeamID an Klammern).

PROVISIONING_PROFILE - Profil ID fir d'Uwendung z'ënnerschreiwen, déi mam Kommando kritt ka ginn:

cd "/Users/$Username/Library/MobileDevice/Provisioning Profiles/" && find *.mobileprovision -type f | xargs grep -li ">${ProjectName}_${Instance}<" | sed -e 's/.mobileprovision//'

Wann d'Applikatioun en zousätzleche Profil benotzt (zum Beispill fir Push Notifikatiounen), dann amplaz PROVISIONING_PROFILE uginn:

APP_PROFILE=”$AppProfile” 
EXTENSION_PROFILE=”$ExtProfile” 

Als nächst sollt déi resultéierend *.app Datei an *.ipa verpackt ginn. Fir dëst ze maachen, kënnt Dir e Kommando benotzen wéi:

/usr/bin/xcrun --sdk iphoneos PackageApplication 
-v $(find "$ProjectDir/build/Build/Products/Release-iphoneos" -name "*.app") 
-o "$ProjectDir/$ProjectName_$Instance.ipa"

Wéi och ëmmer, dës Method gëtt aus der Siicht vun Apple als obsolet ugesinn. Et ass relevant fir *.ipa ze kréien andeems Dir aus dem Applikatiounsarchiv exportéiert.

Als éischt musst Dir d'Archiv mam Kommando sammelen:

xcodebuild 
-workspace $ProjectDir/$ProjectName.xcworkspace 
-scheme $SchemeName 
-sdk iphoneos 
-configuration Release 
archive 
-archivePath $ProjectDir/build/$ProjectName.xcarchive 
CODE_SIGN_IDENTITY=”$DevAccName” 
PROVISIONING_PROFILE=”$ProfileId”
ENABLE_BITCODE=NO 
SYNCHRONOUS_SYMBOL_PROCESSING=FALSE

D'Ënnerscheeder leien an der Montagemethod an Optiounen SYNCHRONOUS_SYMBOL_PROCESSING, déi desaktivéiert d'Symbol Ausluede bei der Bauzäit.

Als nächst musse mir eng Datei mat Export-Astellunge generéieren:

ExportSettings="$ProjectDir/exportOptions.plist"

cat << EOF > $ExportSettings
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>compileBitcode</key>
<false/>
<key>uploadBitcode</key>
<false/>
<key>uploadSymbols</key>
<false/>
<key>method</key>
<string>$Method</string>
<key>provisioningProfiles</key>
<dict>
<key>$BundleID</key>
<string>$ProfileId</string>
</dict>
<key>signingCertificate</key>
<string>$DevAccName</string>
<key>signingStyle</key>
<string>manual</string>
<key>stripSwiftSymbols</key>
<true/>
<key>teamID</key>
<string>$TeamID</string>
<key>thinning</key>
<string><none></string>
</dict>
</plist>
EOF

Wou:

$Method - Liwwermethod, entsprécht dem Typ vun der Applikatioun Ënnerschrëft Profil, dat heescht, fir Entwécklung wäert de Wäert Entwécklung sinn, fir Ad Hoc - ad-hoc, a fir App Store - App-Store.

$BundleID - Applikatioun ID, déi an der Applikatioun Astellunge spezifizéiert ass. Dir kënnt mam Kommando kontrolléieren:

defaults read $ProjectDir/Info CFBundleIdentifier

$DevAccName и $ProfileId - Entwéckler Numm an Ënnerschrëft Profil ID Astellungen déi virdru benotzt goufen a musse mat de Wäerter an den Export Astellunge passen.

$TeamID - Zéng-Ziffer ID an Klammeren nom Entwéckler Numm, Beispill: iPhone Entwéckler: …… (XXXXXXXXXX); kann an Keychain iwwerpréift ginn.

Als nächst, mam Export Kommando, kréien mir déi néideg *.ipa Datei:

xcodebuild 
-exportArchive 
-archivePath $ProjectDir/build/$ProjectName.xcarchive 
-exportPath $ProjectDir 
-exportOptionsPlist $ExportSettings

Shipping info

Elo muss de gesammelt Fichier un den Endbenotzer geliwwert ginn, dat heescht, um Apparat installéiert.

Et gi vill Servicer fir Entwécklung an Ad Hoc Builds ze verdeelen, wéi HockeyApp, AppBlade an anerer, awer an dësem Artikel schwätze mir iwwer e Standalone Server fir Uwendungen ze verdeelen.

D'Installatioun vun der Applikatioun fir iOS fënnt an 2 Etappen statt:

1. Empfang vun der Applikatioun Installatioun Manifest duerch den Items Service.
2. Installatioun vun der *.ipa Datei no der Informatioun, déi am Manifest iwwer HTTPS spezifizéiert ass.

Also musse mir als éischt en Installatiounsmanifest generéieren (Dateityp *.plist) mam Kommando:

cat << EOF > $manifest
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>items</key>
<array>
<dict>
<key>assets</key>
<array>
<dict>
<key>kind</key>
<string>software-package</string>
<key>url</key>
<string>$ipaUrl</string>
</dict>
</array>
<key>metadata</key>
<dict>
<key>bundle-identifier</key>
<string>$BundleID</string>
<key>bundle-version</key>
<string>$AppVersion</string>
<key>kind</key>
<string>software</string>
<key>title</key>
<string>$ProjectName_$Instance</string>
<key>subtitle</key>
<string>$Instance</string>
</dict>
</dict>
</array>
</dict>
</plist>
EOF

Wéi Dir gesitt, enthält de Manifest bal all d'Parameteren déi an der Applikatioun involvéiert sinn.

Applikatioun Versioun ($AppVersion) kann mam Kommando gepréift ginn:

defaults read $ProjectDir/Info CFBundleVersion

Parameter $ipaUrl enthält en direkten Link fir d'*.ipa Datei erofzelueden. Vun der siwenter Versioun vum iOS muss d'Applikatioun iwwer HTTPS installéiert ginn. An der aachter Versioun huet d'Format vum Manifest liicht geännert: Blocks mat Astellunge fir Applikatiounsikonen wéi

<images>
   <image>...</image>
</images>

Also, fir d'Applikatioun z'installéieren, ass eng einfach HTML Säit mat engem Link wéi dësen genuch:

itms-services://?action=download-manifest&url=https://$ServerUrl/$ProjectName/$Instance/iOS/$AppVersion/manifest.plist

Fir d'Bedierfnesser vun den Entwécklungs- an Testdepartementer huet Plarium seng eege Installatiounsapplikatioun erstallt, déi eis gëtt:

• Autonomie an Onofhängegkeet,
• Zentraliséierung vun Zougangskontroll a sécher Installatioun vun Uwendungen duerch "temporär" dynamesch erstallt Linken,
• erweiterbar Funktionalitéit (dat ass, d'Entwécklungsteam, wann néideg, kann fehlend Funktiounen an eng existent Applikatioun integréieren).

Testen

Elo wäerte mir iwwer Pre-Release Testen vun der Applikatioun schwätzen Testfluch.

Néideg Konditioune fir erofzelueden sinn den App Store Ënnerschrëft Profil Typ an d'Präsenz vun generéiert API Schlësselen.

Et gi verschidde Weeër fir d'Applikatioun erofzelueden:

• iwwer Xcode (Organisateur),
• via altool,
• iwwer Applikatioun Loader fir eeler Versioune vun Xcode (elo Transporter).

Fir automatesch Erofluede gëtt Altool benotzt, deen och zwou Autorisatiounsmethoden huet:

• App-spezifesch Passwuert,
• API Schlëssel.

Et ass léiwer d'Applikatioun mam API Key erofzelueden.

Fir den API Key ze kréien, gitt op Link a generéiert e Schlëssel. Zousätzlech zu de Schlëssel selwer am *.p8 Format, brauche mir zwee Parameteren: IssuerID an KeyID.

Als nächst importéiert de erofgeluede Schlëssel op de Build Server:

mkdir -p ~/.appstoreconnect/private_keys
mv ~/Downloads/AuthKey_${KeyID}.p8 ~/.appstoreconnect/private_keys/

Ier Dir d'Applikatioun op TestFlight eropluet, musst Dir d'Applikatioun validéieren, mir maachen dat mam Kommando:

xcrun altool 
--validate-app 
-t ios 
-f $(find "$ProjectDir" -name "*.ipa") 
--apiKey “$KeyID” 
--apiIssuer “$IssuerID” 

Wou apiKey и apiIssuer hunn Feldwäerter vun der API Schlëssel Generatioun Säit.

Als nächstes, no der erfollegräicher Validatioun, luede mir d'Applikatioun mam Kommando --upload-app mat de selwechte Parameteren.

D'Applikatioun gëtt vun Apple bannent engem oder zwee Deeg getest a gëtt dann fir extern Tester verfügbar: Si gi Linken fir d'Installatioun per E-Mail geschéckt.

Eng aner Manéier fir eng Applikatioun duerch altool erofzelueden ass d'App-spezifesch Passwuert ze benotzen.

Fir d'App-spezifesch Passwuert ze kréien, musst Dir op Link a generéiert et an der Sécherheetssektioun.

Als nächst sollt Dir e Build Server Record an Keychain mat dësem Passwuert erstellen. Vun der Versioun 11 vum Xcode kann dëst mam Kommando gemaach ginn:

xcrun altool --store-password-in-keychain-item "Altool" -u "$DeveloperName" -p $AppPswd

Wou:

$DeveloperName - den Numm vum iOS Entwéckler Kont benotzt fir sech op Apple Servicer aloggen.

$AppPswd - generéiert App-spezifesch Passwuert.

Als nächst kréie mir de Wäert vum asc-Provider Parameter a kontrolléiert den Erfolleg vum Passwuertimport mam Kommando:

xcrun altool --list-providers -u "$DeveloperName" -p "@keychain:Altool"

Mir kréien d'Ausgab:

Provider listing:
- Long Name - - Short Name -
XXXXXXX        XXXXXXXXX

Wéi Dir gesitt, fällt den erfuerderleche Kuerznumm-Wäert (asc-Provider) mam $TeamID-Parameter zesummen, dee mir beim Bau vun der Applikatioun benotzt hunn.

Fir d'Applikatioun an TestFlight ze validéieren an ze lueden, benotzt de Kommando:

xcrun altool 
--(validate|upload)-app   
-f $(find "$ProjectDir" -name "*.ipa") 
-u "$DeveloperName" 
-p "@keychain:Altool" 

Als Parameter Wäert -p Dir kënnt de Wäert huelen $AppPswd an onverschlësselte (explizit) Form.

Wéi och ëmmer, wéi scho gesot, aus der Siicht vun der Leeschtung ass et besser API Key fir Altool Autorisatioun ze wielen, well verschidde Versioune vum Xcode verschidde Probleemer hunn ("gesinn net" Keychain, Autorisatiounsfehler beim Eroplueden, etc.).

Dat ass alles, eigentlech. Ech wënschen jidderengem involvéiert erfollegräich Builds an problemfräi Verëffentlechungen am App Store.

Source: will.com