Få iOS Tastaturhøjde Programmatisk: Den Komplette Guide

At skabe en problemfri brugeroplevelse i en iOS-app kræver ofte, at man forstår og reagerer på dynamiske elementer som f.eks. skærmtastaturet. Når tastaturet vises, kan det dække vigtigt indhold, hvilket fører til frustration for brugeren. Derfor er det afgørende at vide, hvordan man programmatisk kan bestemme tastaturets højde, så man kan justere UI'en og sikre, at alt relevant indhold forbliver synligt og tilgængeligt. Denne guide dykker ned i de nødvendige teknikker, fra de grundlæggende notifikationer til de specifikke udfordringer, som nyere enheder som iPhone X og frem byder på, og giver dig de værktøjer, du skal bruge for at mestre tastaturhåndtering i dine applikationer.

Grundlæggende Metoder til Tastaturhøjde Hentning

Den mest ligefremme og pålidelige måde at få adgang til tastaturets højde på iOS er ved at lytte til systemets notifikationer. Apples `NotificationCenter` udsender specifikke notifikationer, når tastaturet ændrer tilstand, herunder når det er ved at vises, skjules eller ændrer sin ramme. Den mest alsidige af disse er UIKeyboardWillChangeFrameNotification.

Sådan Bruger du UIKeyboardWillChangeFrameNotification

Når tastaturet er ved at ændre sin position eller størrelse, sender systemet en notifikation ud. Ved at registrere din view controller (eller enhver anden objekt) som observatør for denne notifikation, kan du fange de nødvendige oplysninger om tastaturets ramme. Her er et simpelt eksempel på, hvordan du kan implementere dette:

- (void)viewDidLoad { [super viewDidLoad]; [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(keyboardWillChangeFrame:) name:UIKeyboardWillChangeFrameNotification object:nil]; } - (void)keyboardWillChangeFrame:(NSNotification *)notification { // Udtræk tastaturets slutramme fra notifikationen CGRect keyboardEndFrame = [notification.userInfo[UIKeyboardFrameEndUserInfoKey] CGRectValue]; CGFloat keyboardHeight = keyboardEndFrame.size.height; // Log højden for at se værdien NSLog(@"Tastaturhøjde: %f", keyboardHeight); // Her kan du opdatere dine AutoLayout-constraints eller contentInsets // ... } - (void)dealloc { // Husk at fjerne observatøren for at undgå memory leaks [[NSNotificationCenter defaultCenter] removeObserver:self name:UIKeyboardWillChangeFrameNotification object:nil]; } 

Lad os nedbryde, hvad der sker her:

• addObserver:selector:name:object:: Denne metode registrerer din view controller som en observatør.
• selector:@selector(keyboardWillChangeFrame:): Angiver den metode, der skal kaldes, når notifikationen modtages.
• name:UIKeyboardWillChangeFrameNotification: Dette er nøglenotifikationen. Den er især nyttig, fordi den udløses ved alle tastaturrammeændringer – ikke kun når tastaturet vises eller skjules – hvilket inkluderer rotation, autosuggestioner og endda eksterne tastaturer.
• notification.userInfo: Dette er en ordbog, der indeholder detaljer om tastaturets ændring.
• UIKeyboardFrameEndUserInfoKey: Denne nøgle i userInfo-ordbogen indeholder NSValue-objektet, som omslutter den CGRect, der repræsenterer tastaturets slutramme i skærmens koordinatsystem.
• CGRectValue().size.height: Ved at kalde CGRectValue() på NSValue-objektet får du den faktiske CGRect, og derfra kan du nemt udtrække height-egenskaben.

Udover UIKeyboardFrameEndUserInfoKey, kan userInfo-ordbogen også indeholde andre nyttige nøgler som UIKeyboardAnimationDurationUserInfoKey og UIKeyboardAnimationCurveUserInfoKey. Disse giver dig mulighed for at matche animationen af din UI-justering med tastaturets egen animation, hvilket resulterer i en mere flydende og professionel brugeroplevelse.

Håndtering af Autosuggestioner og AutoLayout

Siden iOS 8 introducerede Apple autosuggestionsbjælken (også kendt som QuickType-bjælken) øverst på tastaturet. Denne bjælke er en integreret del af tastaturet og udvider dets samlede højde, når den er synlig. Det er en vigtig detalje at huske, når du designer og implementerer din UI med AutoLayout.

Når du modtager UIKeyboardWillChangeFrameNotification, vil den rapporterede højde for tastaturet automatisk inkludere autosuggestionsbjælken, hvis den er synlig. Dette betyder, at du normalt ikke behøver at foretage separate beregninger for den. Din AutoLayout-logik skal blot reagere på den samlede højde, der returneres af notifikationen.

En typisk anvendelse er at justere en bundbegrænsning (bottom constraint) på en UIScrollView eller en UITextView, så indholdet kan scrolle op over tastaturet. Du kan opnå dette ved at oprette en IBOutlet til din bundbegrænsning og derefter opdatere dens constant-værdi i din keyboardWillChangeFrame:-metode:

@IBOutlet weak var scrollViewBottomConstraint: NSLayoutConstraint! func keyboardWillChangeFrame(_ notification: Notification) { guard let userInfo = notification.userInfo else { return } guard let keyboardEndFrame = (userInfo[UIKeyboardFrameEndUserInfoKey] as? NSValue)?.cgRectValue else { return } guard let animationDuration = (userInfo[UIKeyboardAnimationDurationUserInfoKey] as? NSNumber)?.doubleValue else { return } guard let animationCurveRawValue = (userInfo[UIKeyboardAnimationCurveUserInfoKey] as? NSNumber)?.intValue else { return } let animationCurve = UIView.AnimationCurve(rawValue: animationCurveRawValue) ?? .easeInOut let keyboardHeight = view.frame.height - keyboardEndFrame.minY let safeAreaBottomInset = view.safeAreaInsets.bottom // Juster bundbegrænsningen. Hvis tastaturet er skjult, skal højden være 0. // Ellers skal den være tastaturets højde minus safe area bottom inset for at undgå dobbeltjustering. if keyboardEndFrame.minY == view.frame.height { scrollViewBottomConstraint.constant = 0 } else { scrollViewBottomConstraint.constant = keyboardHeight - safeAreaBottomInset } UIView.animate(withDuration: animationDuration, delay: 0, options: UIView.AnimationOptions(rawValue: UInt(animationCurve.rawValue))) { self.view.layoutIfNeeded() } } 

I dette eksempel beregnes tastaturets højde ved at trække tastaturets Y-koordinat (keyboardEndFrame.minY) fra visningens samlede højde (view.frame.height). Dette giver den faktiske højde, som tastaturet optager på skærmen. Vi trækker også safeAreaInsets.bottom fra, da tastaturet allerede tager højde for safe area, og vi ønsker ikke at justere dobbelt.

Særlige Overvejelser for iPhone X og Nyere Modeller

Med introduktionen af iPhone X og dens "notch"-design opstod nye udfordringer for UI-udviklere, især i forhold til "safe area insets" og den faste hjemmeindikator-bjælke nederst på skærmen. Apples designretningslinjer foreskriver, at tastaturets top skal være cirka 2 tommer fra bunden af selve enheden, når den holdes. Før iPhone X var dette ligetil, da alle enheder havde de samme bezel-indstillinger, hvilket gjorde det til en fast 216 punkter fra bunden af skærmen.

På iPhone X og nyere modeller er situationen mere kompleks. safeAreaInsets alene er ikke altid tilstrækkeligt til at beregne den ønskede afstand fra enhedens fysiske bund. Tastaturet er designet til at sidde over hjemmeindikatoren, og dets ramme vil automatisk tage højde for dette. Den højde, du får fra UIKeyboardFrameEndUserInfoKey, er den faktiske højde, tastaturet optager, inklusive den del, der sidder over hjemmeindikatorområdet.

Den oprindelige tilgang, som nogle udviklere brugte, var at oprette udvidelser til UIScreen for at definere standard bezel-indstillinger baseret på enhedens skærmstørrelse:

@implementation UIScreen(MyExtensions) - (UIEdgeInsets)standardBezelInsets { CGSize iPhoneXSize = CGSizeMake(375, 812); // specifik størrelse for iPhone X, XS, 11 Pro if (CGSizeEqualToSize(self.bounds.size, iPhoneXSize)) { return (UIEdgeInsets) { .top = 43, .bottom = 74 }; // Eksempelværdier } return UIEdgeInsetsZero; } @end @implementation MyKeyboardView - (CGFloat)preferredHeight { // Forsøg på at forudberegne en 'ønsket' højde return [[UIScreen mainScreen] standardBezelInsets].bottom + 216; } // ... @end 

Denne metode har dog flere ulemper:

• Hårdkodede Værdier: Den afhænger af hårdkodede skærmstørrelser (f.eks. CGSizeMake(375, 812)), hvilket gør den sårbar over for nye iPhone-modeller med forskellige dimensioner.
• Ikke Dynamisk: Den forsøger at forudsige en højde i stedet for at reagere på den faktiske, dynamiske tastaturramme, som systemet rapporterer.
• Kompleksitet: Tilføjelse af kategorier til UIScreen for specifikke enhedslogikker kan gøre koden mindre overskuelig og sværere at vedligeholde.

En bedre og mere robust tilgang er at stole på systemets rapporterede tastaturramme og derefter justere din UI ved at tage højde for safeAreaInsets, hvor det er relevant. Når tastaturet vises på en iPhone X eller nyere, vil UIKeyboardFrameEndUserInfoKey give dig den korrekte ramme i skærmens koordinatsystem. Tastaturet vil naturligt sidde oven på hjemmeindikatorområdet.

Hvis du for eksempel vil justere en UIScrollView's contentInset.bottom, skal du tage tastaturets højde og fratrække den nederste safeAreaInset. Dette sikrer, at dit scrollbare indhold stopper præcis ved tastaturets top, uden at der justeres for meget, da tastaturet allerede dækker safe area:

// Inden for keyboardWillChangeFrame: metoden let keyboardEndFrame = (notification.userInfo![UIKeyboardFrameEndUserInfoKey] as! NSValue).cgRectValue let duration = (notification.userInfo![UIKeyboardAnimationDurationUserInfoKey] as! NSNumber).doubleValue let curve = UIView.AnimationCurve(rawValue: (notification.userInfo![UIKeyboardAnimationCurveUserInfoKey] as! NSNumber).intValue)! // Swift 5+ syntax // Tastaturets top-Y-koordinat i forhold til din views koordinatsystem let keyboardTopY = view.convert(keyboardEndFrame, from: view.window).minY // Højde fra bunden af din view til tastaturets top let distanceToKeyboard = view.frame.height - keyboardTopY // Juster contentInset.bottom for din scroll view let newInset = max(0, distanceToKeyboard - view.safeAreaInsets.bottom) UIView.animate(withDuration: duration, delay: 0, options: UIView.AnimationOptions(rawValue: UInt(curve.rawValue))) { self.myScrollView.contentInset.bottom = newInset self.myScrollView.scrollIndicatorInsets.bottom = newInset self.view.layoutIfNeeded() } 

Denne metode er mere fremtidssikker, da den ikke afhænger af specifikke enhedsstørrelser, men udelukkende af de dynamiske værdier, som systemet leverer. Den respekterer også safeAreaInsets, som er den anbefalede måde at håndtere layout på tværs af forskellige enheder med notches og hjemmeindikatorer.

Bedste Praksis og Avancerede Teknikker

For at sikre en robust og vedligeholdelsesvenlig implementering af tastaturhåndtering er der flere bedste praksisser og avancerede teknikker, du bør overveje:

Fjern Observatører Korrekt

Det er absolut afgørende at fjerne dine notifikations-observatører, når de ikke længere er nødvendige, typisk i dealloc-metoden for en Objective-C view controller eller i viewWillDisappear (eller lignende) for Swift. Hvis du undlader dette, kan det føre til retain cycles, memory leaks og potentielle crashes, især hvis observatørobjektet destrueres, men NotificationCenter stadig forsøger at sende notifikationer til det.

Håndtering af Flere Tekstfelter

I apps med flere tekstfelter (f.eks. login-formularer eller indstillingsskærme) kan tastaturet dække det aktive tekstfelt. En god brugeroplevelse indebærer automatisk at scrolle til det aktive felt, så det er synligt. Dette kan opnås ved at bruge scrollRectToVisible:animated: på din UIScrollView, efter at du har justeret dens contentInset. Du skal vide, hvilket tekstfelt der er aktivt (f.eks. ved at implementere UITextFieldDelegate's textFieldDidBeginEditing:).

UIKeyboardLayoutGuide (iOS 15+)

For Swift-udviklere, der sigter mod iOS 15 og nyere, har Apple introduceret UIKeyboardLayoutGuide. Dette er en moderne, deklarativ måde at håndtere tastaturlayout på, som forenkler AutoLayout-justeringer betydeligt. I stedet for manuelt at lytte til notifikationer kan du blot knytte dine views til denne layout guide, og systemet håndterer justeringen automatisk. Dette er den anbefalede tilgang for nye projekter og for dem, der kan understøtte iOS 15+.

// Eksempel med UIKeyboardLayoutGuide (kun Swift/iOS 15+) // I din UIViewController's viewDidLoad eller lignende // Bind din scroll view's bund til tastaturets layout guide myScrollView.bottomAnchor.constraint(equalTo: view.keyboardLayoutGuide.topAnchor).isActive = true // Eller tilføj polstring myScrollView.bottomAnchor.constraint(equalTo: view.keyboardLayoutGuide.topAnchor, constant: -padding).isActive = true 

UIKeyboardLayoutGuide tilbyder en mere elegant og mindre fejlbehæftet løsning sammenlignet med manuel notifikationshåndtering, da den integrerer direkte med AutoLayout-systemet.

Adaptive UI og Animationer

Sørg for, at dine UI-justeringer animeres problemfrit sammen med tastaturets bevægelse. Ved at bruge UIKeyboardAnimationDurationUserInfoKey og UIKeyboardAnimationCurveUserInfoKey fra notifikationen, som vist tidligere, kan du indkapsle dine layoutændringer i en UIView.animate-blok med de samme varighed og kurve som tastaturet. Dette skaber en meget mere poleret og professionel app-oplevelse.

Sammenligningstabel: Tastaturhøjde på Forskellige Enheder

Selvom den programmatiske tilgang via UIKeyboardWillChangeFrameNotification er den mest pålidelige, kan det være nyttigt at have en idé om, hvordan tastaturhøjden typisk varierer på tværs af forskellige iOS-enheder. Bemærk, at disse værdier er omtrentlige og kan ændre sig med iOS-versioner og sprogindstillinger.

Ansvarsfraskrivelse: Disse værdier er estimater og kan variere afhængigt af den specifikke iOS-version, enhedsmodel, sprogindstillinger og tilstedeværelsen af eksterne tastaturer. Brug altid den dynamisk hentede højde fra UIKeyboardFrameEndUserInfoKey for præcis justering.

Ofte Stillede Spørgsmål (FAQ)

Hvorfor er det vigtigt at kende tastaturhøjden?

At kende tastaturhøjden er afgørende for at forhindre, at tastaturet dækker vigtigt indhold i din app. Ved at justere din UI dynamisk kan du sikre, at brugeren altid kan se de tekstfelter, de skriver i, samt eventuelle knapper eller information, der er placeret nederst på skærmen. Dette forbedrer appens brugervenlighed og professionelle udseende.

Hvordan håndterer jeg tastaturrotation (portræt/landskab)?

Den gode nyhed er, at UIKeyboardWillChangeFrameNotification automatisk håndterer rotation. Når enheden roteres, vil tastaturets ramme ændre sig, og notifikationen vil blive udløst med den nye ramme for den ændrede orientering. Din eksisterende logik til at udtrække højden vil derfor fortsat fungere uden yderligere ændringer.

Er der forskel på fysiske og softwaretastaturer?

Ja, der er en væsentlig forskel. De notifikationer, vi har diskuteret (f.eks. UIKeyboardWillChangeFrameNotification), udløses kun af det virtuelle (software) tastatur på skærmen. Hvis en bruger forbinder et eksternt (fysisk) tastatur, vil det virtuelle tastatur typisk forsvinde, og ingen af disse notifikationer vil blive udløst, da det fysiske tastatur ikke optager skærmplads. Derfor behøver du ikke at justere din UI i disse tilfælde.

Skal jeg fjerne observatører?

Ja, absolut! Det er en kritisk bedste praksis at fjerne observatører, når det observerende objekt ikke længere er aktivt eller eksisterer. Hvis du ikke gør det, kan NotificationCenter forsøge at sende notifikationer til et frigivet (deallocated) objekt, hvilket resulterer i en crash (typisk en `EXC_BAD_ACCESS`). For en UIViewController er den bedste placering at fjerne observatøren i dealloc (Objective-C) eller i viewWillDisappear/deinit (Swift).

Hvad er den bedste måde at justere mit AutoLayout på?

Den mest almindelige og anbefalede måde er at justere en bundbegrænsning på din scroll view eller den container, der indeholder dit indhold. Du kan oprette en IBOutlet til denne begrænsning og derefter opdatere dens constant-værdi i din keyboardWillChangeFrame:-metode. For iOS 15 og nyere er UIKeyboardLayoutGuide den mest moderne og simple tilgang, da den integrerer direkte med AutoLayout.

Ved at følge de principper og teknikker, der er beskrevet i denne guide, er du godt rustet til at håndtere iOS tastaturets højde på en professionel og brugervenlig måde. Uanset om du arbejder med ældre iOS-versioner og manuel notifikationshåndtering eller udnytter de nyere AutoLayout-guides, vil en korrekt implementering sikre, at dine apps altid præsenterer et poleret og funktionelt interface for dine brugere.

Hvis du vil læse andre artikler, der ligner Få iOS Tastaturhøjde Programmatisk: Den Komplette Guide, kan du besøge kategorien Teknologi.