DEVELOPMENT NOTES · 2015–2017
Keep the problem. Keep the thinking.
128 historical notes, organised by topic from interface animation to audio and video. Original publication dates, article addresses and code are retained so you can follow an idea through the archive.
These articles describe the development environments of their time. Examples have not been rerun for this archive update. Each article includes its own authorship, source and version context.
Choose a topic
UIKit & graphics
Layout, lists, gestures, rich text, UIView, Core Animation and drawing.
Explore topic 02 15 articlesSwift & runtime
Swift language notes, Objective-C messaging, KVO, blocks and code organisation.
Explore topic 03 7 articlesConcurrency & performance
Threads, RunLoop, keeping a thread alive, UI stalls and performance investigation.
Explore topic 04 24 articlesData & networking
Core Data, caching, network requests, messaging, notifications and system services.
Explore topic 05 20 articlesTools & releases
CocoaPods, Git, static libraries, Xcode, testing, compatibility and release notes.
Explore topic 06 5 articlesAudio & video development
Building FFmpeg, H.264 decoding, capture, streaming and player integration.
Explore topic 07 9 articlesWeb & development notes
WebView, JavaScript bridges, mini programs, blog maintenance and development reflections.
Explore topicAll articles
128 articles · grouped by topicUIKit & graphics
Reading notes & full list-
Custom iOS Transitions with a Two-Line API
Introduces WTKTransitionAnimate, selecting transitions through a navigation delegate and factory methods. It combines drag gestures with percentage-based progress to implement an interactive back transition and explains the organization behind the wrapper.
-
Practical UITextField Input Rules and Keyboard Handling
Addresses text length, numeric and currency input, Chinese input composition, and keyboard overlap. Categories and runtime features organize extensible input rules, while keyboard notifications are used to adjust the interface position.
-
Animating iOS Buttons with Core Animation
Builds on Core Animation fundamentals to animate button gradients and shapes with CALayer, CABasicAnimation, and animation groups. It explains layer properties, timing, and the organization of cooperating animations.
-
Recreating the Profile Avatar Wave Animation in Baidu Waimai
Breaks down the waves around a profile avatar: CADisplayLink drives updates, trigonometric functions generate the curves, and CAShapeLayer draws them. It explains the components needed for a continuous wave animation.
-
iOS game development with UIKit: Hardest
Introduces the structure of the Hardest mini-game built with Objective-C and UIKit, including level selection, game state, score calculation, sound effects and saved data. It also distinguishes this exercise from work better suited to a dedicated game engine.
-
Breaking Down a Complex iOS Animation: Objective-C and Swift
Breaks a welcome-screen animation into circular scaling, elliptical compression, edge bulges, rotation, and a wave fill. The article sequences layer and path changes to show how a visual effect can be translated into implementable animation steps.
-
An introduction to Core Animation on iOS
Introduces Core Animation through CALayer, CAAnimation and CAAction, explaining the relationship between layers and animation objects, timing control and action lookup. Examples distinguish the organisation of implicit and explicit animations.
-
Adding a launch advertisement to an iOS app
Wraps a launch-ad view with full-screen and bottom-logo layouts. SDWebImage fetches the ad image, while opacity animation and block callbacks handle presentation, taps and dismissal.
-
iOS animation: a fragment-based reveal
Explains how UIView's maskView affects which content is visible, then divides the mask into regions and animates them separately. These steps build a fragmented reveal and an image-carousel transition.
-
Rich text with hyperlinks on iOS
Draws attributed strings with Core Text, inserts images into reserved text positions and adds hyperlink interaction, then compares the approach with TextKit. The examples connect the basic steps needed for chat emoji and mixed text-and-image layout.
-
Building a Pomodoro timer app for iOS
Connects timers, notification reminders, music playback and a Today Widget in a Pomodoro app. It identifies implementation entry points for card layouts, transitions, xib files and URL Schemes, helping readers follow how the features fit together in the project.
-
iOS animation: a closer look at layout animation
Uses an expanding account list and a shrinking button on a login page to demonstrate animating top, height and horizontal-margin constraints. It examines how the view hierarchy and constraint changes work together to produce a continuous transition.
-
A circular expanding transition in Swift, inspired by Gewara
Moves from an ordinary navigation push to an expanding circular transition, using a CALayer mask to control the revealed area. Gesture-driven animation extends the example, which is explained in Swift with an Objective-C implementation for comparison.
-
Building a WeChat-style iOS app, part 7
Breaks down the chat input bar and message cells, using blocks to send submission and visibility events to the controller. Message ownership determines avatars and stretchable bubble backgrounds, while model-side sizing accommodates messages of different lengths.
-
Core Graphics for Swift developers: an in-depth introduction
Starts with obtaining a drawing context and constructing paths, then draws rectangles, circles, curves, text and images in Swift. Further examples cover linear and radial gradients, blend modes, coordinate transforms, and bitmap and PDF output.
-
A first look at Auto Layout animation on iOS
Introduces constraints through text layouts in portrait and landscape, then breaks down an interface that animates as a list scrolls. Changing constraint values controls element positions and sizes, demonstrating the basics of combining Auto Layout with animation.
-
GitHub source-code picks, February 22: SmallDay and LoveFreshBeen in Swift 2.0
Selects two Swift 2.0 recreation projects, SmallDay and LoveFreshBeen. Repository links and an introduction to their author let readers inspect complete projects to study screen organisation and UI implementation.
-
A custom pull-to-refresh control in Swift
Creates a text view in a xib file to cover UIRefreshControl's default appearance, then rotates, recolours and scales the letters in stages. Simulated loading and row insertion connect the beginning and end of the custom refresh workflow.
-
Custom iOS view-controller transitions in practice
Distinguishes the roles of from, to and presenting controllers, then implements custom modal and navigation transitions. Interactive animations and the transition coordinator extend the examples and explain how to organise reusable animation logic.
-
iOS animation: transforms and keyframes
Uses changing seasonal text and falling leaves to explain affine transforms and keyframe animation. Scaling, translation and rotation are combined step by step, showing how transform parameters and animation stages affect the resulting motion.
-
Core Text layout in Swift 2.0, continued
Builds on basic Core Text layout by examining baselines, ascenders, descenders and other font metrics. Drawing line by line gives Chinese text and emoji consistent line heights, before extending the rich-text interaction to links and mentions.
-
Building a WeChat-style iOS app, part 3
Continues the main interface by exposing constraints from xib files and adjusting their constant values for the screen. It also refines navigation-bar button positions and loads images with SDWebImage placeholders.
-
Core Text layout in Swift 2.0: an in-depth introduction
Begins with attributed-text properties such as fonts, colours and ranges, then introduces Core Text's layout and drawing steps. Combining text and images illustrates the basic objects needed for more complex text interfaces.
-
Building a WeChat-style iOS app, part 2
Builds the Contacts, Discover and profile screens using grouped UITableViews and a custom personal-information cell. Sorting and grouping the contact data demonstrates the initial interface structure shared by several pages.
-
Building a WeChat-style iOS app, part 1
The opening instalment organises the project and its MVC folders, introduces shared view controllers, and creates the feature pages and UITabBarController. It establishes the common navigation structure that later screens will use.
-
Moving cell images as a table view scrolls
Adjusts an image's position using the offset between the cell's centre and its parent view's centre, creating parallax during UITableView scrolling. It records the custom cell and visible-item updates, with adapted code and a link to the original project.
-
iOS animation: starting with UIView animations
Uses a login screen's arriving text fields and appearing button to introduce animatable UIView properties, duration and options. Adding spring animations shows how position, opacity and transforms can be combined into a continuous sequence.
-
Understanding parallax animation in iOS
Explains parallax through the positions of several view layers. Dragging the middle layer, compensating for the text layer's offset and clipping overflow keeps the text stationary relative to the bottom layer, showing how occlusion and movement combine.
-
A League of Legends skin-selection animation with UICollectionViewFlowLayout
Builds a character-skin selection effect with a custom UICollectionViewFlowLayout. It adjusts layout attributes and the final scroll position, then integrates the layout subclass into the collection view to keep the selected card centred.
-
Recreating pop-up effects from Jianshu and Taobao on iOS
Separates the effect into content, a dimming overlay and the presented view. Two-stage layer transforms and dismissal animation make the background appear to recede, while the article explains the stacking order when adding views to a window.
-
Recreating an animation from the National Geographic iOS app
Breaks down a National Geographic-inspired pop-up page animation into status-bar hiding, view dragging and spring-back, navigation-bar coordination and back-button colour changes. The implementation follows how several interface layers move together.
-
Building a custom pop-up view with HWPopTool
Introduces HWPopTool integration and its controls for the content view, background overlay and close button. It also explains how to handle closing after the component changed its callback mechanism from a delegate to a block.
-
Event delivery and the responder chain in iOS
Uses UIResponder, UIEvent and UITouch to explain how touch events reach views. Custom views reveal the relationship between the responder chain and gestures, followed by discussion of how event-delivery behaviour can be used in an interface.
-
A Windows AliWangWang-style login screen with a paper-feed animation
Recreates the printer-paper login animation from Windows AliWangWang. Keeping the view's horizontal position and width fixed while gradually adjusting its height creates the unfolding effect; the LBPrinterPaper project supplies the example.
-
GitHub source-code picks, December 25: gesture unlock, a profile SDK and an image carousel
Collects three open-source components for gesture unlocking, a profile page and an infinite image carousel. Download links and selected integration code help readers identify the component that matches an interface requirement.
-
Mac development series: NSImageView
Demonstrates creating an NSImageView, assigning an image and adding it to a macOS interface. Enabling its backing layer and configuring corner radius and border then produces a circular avatar style.
-
Integrating an endlessly flipping 3D banner in one minute
Combines left and right swipe gestures with transition animations to cycle through banner images in 3D. It covers component import and tap delegation, while explicitly noting that the effect uses a private animation API and is retained as a technical experiment.
-
iOS 9 3D Touch quick actions, with a Swift update
Explains iOS 9 Home Screen quick actions: defining icons, titles and types in Info.plist, then dispatching selections through AppDelegate. Both Objective-C and Swift implementations illustrate the configuration and callback flow.
-
Building a UICollectionView programmatically in Swift
Starts with data-source and delegate setup, then builds UICollectionView cells, loads network data and adds reusable headers. These steps bring together the structure of a collection-view interface implemented entirely in Swift code.
-
A Swift profile page with a simple integration
Shows how to integrate the Swift version of a profile-page component. Importing LBSwift_PersonalPage and inheriting from its controller reuses the interface, while the example code demonstrates the relationship between the wrapper and its callers.
-
An iOS profile page in one minute
Introduces integration of the LBPersonalPage_VC profile-page component. Importing its files, inheriting from the base controller and adding configuration lets a project reuse the page's visual behaviour; the example project provides the implementation details.
-
Exploring Swift: building a tab bar entirely in code
Builds a Zhe800-inspired tab bar using early Swift syntax. It creates child view controllers, assigns titles and icons, and adds them to the system tab bar, illustrating how to organise a navigation structure programmatically.
-
Disabling the system swipe-back gesture on iOS
Addresses an embedded game unexpectedly revealing navigation and tab bars during a swipe. The article shows where to control the navigation controller's built-in back gesture and records how that interaction was disabled for a particular screen.
-
Animating a view around another view on iOS
Explains how to move a view around the centre of an image. Trigonometric functions calculate points on a circle, and updating the view coordinates produces an orbiting animation without a complex animation framework.
-
Creating long-form Weibo images in an iOS app
Turns a long passage of text into an image for a long-form Weibo post. The code works through text width, font size, required height and image drawing, demonstrating an early UIKit approach to generating a tall image at a fixed width.
-
Google Maps on iOS: markers and route playback
Records a Google Maps integration intended to make map presentation consistent across iOS and Android. It includes the main code for map initialisation, markers and route lines, along with the setup entry point for obtaining a maps API key.
-
A small iOS scrolling demo inspired by Zhe800
Uses a Zhe800-style scrolling interaction to demonstrate recording contentOffset when dragging begins and comparing offsets in scroll callbacks to determine direction. An example project shows how the interface elements respond together.
-
Calculating label heights automatically in a table view
Calculates the height a label needs from its font, constrained width and measured text, then adds spacing in the UITableView row-height callback. The code illustrates manual sizing of multiline labels and table-view cells.
Swift & runtime
Reading notes & full list-
Bitwise Operations in iOS
Introduces bitwise AND, OR, XOR, and NOT, using packed RGBA colors and state flags as examples. It then explains how enumerations and masks can store and query several states together.
-
Balancing Code Responsibilities in iOS
Uses an example project to examine oversized MVC controllers and the responsibilities of views, models, and controllers. It extracts repeated logic and reassigns functionality, emphasizing clear ownership of code before switching architecture labels.
-
Swift 3.0 Design Patterns: Singleton
Introduces the uses and trade-offs of Swift singletons, creating shared instances with a static class constant or a global constant. It covers private initializers, access across modules, and the need to consider thread safety for shared mutable state.
-
Swift 3.0 Design Patterns: Flyweight
Introduces the flyweight pattern through shared local-data managers. A dictionary reuses loaded data and tracks usage counts; unused data is saved and released. The example contrasts this lifecycle with a singleton that remains in memory.
-
Protocols and Delegation in iOS
Uses UITableView and custom controls to distinguish protocols from delegation. It compares delegate and block callbacks, then discusses how data sources and protocol abstractions can reduce coupling between objects.
-
Objective-C Runtime in Practice: Mapping Dictionaries to Models
Moves from manual assignment, KVC, and third-party model libraries to an NSObject category that traverses runtime information and maps dictionaries to models. It also defines the example's support for two levels of nested data.
-
Decoupling iOS Views from Concrete Model Types
Uses several types of ticket data with different fields but similar presentation needs to explore a dictionary-backed approach. A protocol exposes common display properties, reducing cells' and controllers' dependence on specific models and clarifying where data conversion belongs.
-
Swift in practice: the template pattern
Uses product data and calculations to examine code that depends on a tuple's structure. Types and protocols then organise reusable processing, showing how abstraction can reduce coupling between parameter formats and business methods.
-
Reading the Objective-C runtime source to understand messaging
Uses an unrecognized selector error to introduce Objective-C messaging, examining method lookup, caching and forwarding in the source. Runtime examples then explain how a method call is resolved during execution.
-
Objective-C runtime in practice: changing fonts throughout an interface
Starts with registering a custom font and finding its name, then uses Objective-C runtime techniques to replace interface fonts. It discusses the differences between controls created in code and those loaded from a storyboard when applying a common setting.
-
Understanding blocks in iOS development
Starts with block declarations and calls, then examines captured variables and callback wrappers. Examples modelled on Swift's higher-order functions demonstrate how blocks can be used to process data in Objective-C.
-
iOS refactoring notes: Extract Method
Applies the Extract Method technique from Refactoring to split long stretches of code into functions organised by intent. Parameters, local variables and return values are handled step by step, with examples showing how to reduce repetition and improve readability.
-
Seven Swift pitfalls and how to avoid them
Uses code examples to investigate surprising behaviour in protocol extensions, optional-chain assignment and functional processing. It compares dispatch for value and reference types and explains how code can compile successfully while producing an unexpected result.
-
Inside KVO on iOS
Starts with observing a list's scroll offset, then examines the dynamic subclass and isa-pointer changes caused by registering an observer. Runtime functions are used to attempt a similar mechanism, connecting practical KVO usage with its underlying behaviour.
-
Objective-C runtime fundamentals: properties and instance variables
Distinguishes Objective-C properties from instance variables, examining runtime structures, memory offsets and synthesize to explain how properties are generated. Examples then show why dynamically inspecting and manipulating an object's structure can be useful.
Concurrency & performance
Reading notes & full list-
Detecting iOS Main-Thread Stalls
Detects stalls by monitoring the main thread's RunLoop state and wait timeouts. It then introduces retrieving thread stack frames, walking call stacks, and symbolication to capture useful diagnostic context while an app is running.
-
RunLoop and Keeping iOS Threads Alive
Uses the networking thread in AFNetworking 2.x to examine RunLoop-based thread lifetimes. It explains how copied run-loop code can retain objects or prevent threads from exiting, then explores more controlled lifecycle handling through examples.
-
Optimising UITableViewCell height calculation in Swift
Addresses repeated cell-height calculation by drawing on FDTemplateLayoutCell's template measurement and height-caching approach. A Swift wrapper reduces repeated work during table-view scrolling.
-
UIKit performance tuning in practice
Uses a list interface as an experiment and Instruments' Core Animation tools to examine layer blending, image dimensions, colour formats and offscreen rendering. It connects common scrolling-performance problems with targeted adjustments.
-
Bison's guide to iOS multithreading, part 3
Explores GCD tasks and queues, comparing the main queue, global queues and custom serial and concurrent queues. Image downloads, repeated execution and one-time initialisation illustrate common ways to submit work.
-
Bison's guide to iOS multithreading, part 2
Examines shared data accessed by several threads, introducing synchronized blocks and NSLock locking and unlocking. NSCondition examples then use waiting, signalling and broadcasting to explain coordination between threads.
-
Bison's guide to iOS multithreading, part 1
Introduces multithreading by distinguishing processes from threads and comparing NSThread, NSOperationQueue and GCD. It then demonstrates thread creation, execution, termination and priorities, using logs to observe scheduling behaviour.
Data & networking
Reading notes & full list-
DNS Hijacking and Request Handling in iOS
Introduces DNS hijacking through unexpected name-resolution results, then describes using NSURLProtocol to adjust requests and resolution. It discusses compatibility boundaries involving IPv6, WebKit, and NSURLSession and retains the implementation examples and references.
-
Reading CocoaAsyncSocket: Completing the Connection
Continues tracing the CocoaAsyncSocket connection process from local-address binding to connection establishment and callbacks. Low-level socket operations explain the order of asynchronous execution and the purpose of the relevant configuration.
-
Reading CocoaAsyncSocket: Connection Setup
Follows GCDAsyncSocket initialization and connection entry points through the CocoaAsyncSocket source. It traces parameter checks, local and server address creation, and socket configuration before connecting, using annotated code to explain the call sequence.
-
iOS 10 Notifications, Part 2: Service Extensions
Explains how a Notification Service Extension processes content before a notification appears. It covers creating an extension target, changing text, loading attachments, and falling back to the original notification when processing times out.
-
iOS 10 Notifications, Part 1: Requests, Triggers, and Attachments
Uses local notifications to explain the relationship between UNNotificationRequest, triggers, and the notification center. It manages additions, updates, and deletions through identifiers and introduces valid file paths and configuration for notification attachments.
-
iOS 10 Push Notifications: The Basics
Starts with enabling push capabilities and checking an existing project's configuration, then introduces iOS 10 notification registration, notification-center delegates, and callbacks. Third-party push integration illustrates the API changes involved in migrating older code.
-
Wrapping automatic object archiving and unarchiving on iOS
Starts with NSCoding and uses the runtime to enumerate instance variables and organise encoding. The WZXArchiver wrapper develops step by step, with discussion of child objects and the limits of automated storage.
-
A first look at PhotoKit in Swift
Uses a multi-photo picker to introduce PhotoKit, including the maximum selection count, returning an array of PHAsset objects and invoking a closure. The album project and learning resources document an attempt to move from AssetsLibrary to PhotoKit.
-
MVVM and chained network-request architecture
Begins with growing business logic in a view controller, using a sign-in decision to separate Model, ViewModel and ViewController responsibilities. It then introduces ReactiveCocoa and a chained network-request wrapper for organising business calls.
-
Combining AES encryption with Base64 encoding on iOS
Defines categories for NSData and NSString to demonstrate a workflow combining AES encryption and decryption with Base64 encoding. It notes that the client and server must agree on the same key and provides a complete demonstration project.
-
Building a Swift local-cache library step by step
First distinguishes Documents, Caches, Preferences and temporary directories, then wraps a local file cache for objects, images and audio. Offline-browsing scenarios explain directory management and the approach to reading and writing cached content.
-
Building a WeChat-style iOS app, part 6
Records three issues after integrating chat: matching keyboard animation parameters, managing observers as the app enters and leaves the background, and preserving sign-in state. It includes the handling code and explicitly limits the simplified automatic sign-in example.
-
Remote notifications with JPush: a detailed integration guide
Prepares remote notifications through App ID configuration, push capabilities and certificate requests, then integrates the JPush SDK. Development and production settings, certificate export and client callbacks document an early push-notification setup workflow.
-
Building a WeChat-style iOS app, part 5
Continues the profile and Moments screens, using AVUser for registration and sign-in and AVFile for avatar uploads. Image compression reduces transfer size, while notes document issues with a pull-down header image and refresh components.
-
Building a WeChat-style iOS app, part 4
Adds cloud-storage and instant-messaging dependencies, wraps sign-in and registration methods, and records troubleshooting while querying user data. An early experiment with a password field is included as part of this historical development account.
-
Do you need Alamofire? Trying NSURLSession instead
Introduces NSURLSession through a simple data request, distinguishes data, download and upload tasks, and compares default, ephemeral and background configurations. It connects those choices with caching, cookies and the organisation of network tasks.
-
Integrating LianLian Pay into an iOS app
Organises the linker options, resource styles and business fields required by the LianLian Pay SDK. It explains user identifiers, card-binding agreements and server callbacks, with notes on signatures and UI customisation settings that are easy to confuse.
-
Understanding and using Core Data for persistence
Explains the relationship between managed objects, contexts and the persistent store coordinator, then sets up Core Data and an entity model manually. Examples of creating, fetching, updating and deleting objects illustrate the main persistence workflow.
-
GitHub source-code picks, January 4: Bluetooth, launch animations and a custom tab bar
Selects the BabyBluetooth framework, CLClipImageView launch animation and CYLTabBarController tab bar. Project links and selected usage examples introduce the components, including the distinction between Bluetooth central and peripheral modes.
-
OCR for debit and credit cards in iOS development
Introduces card.io SDK integration for scanning card numbers, including linker settings, delegates and recognition callbacks. Objective-C and Swift examples accompany the workflow; the article specifies that the selected implementation is for credit-card scanning.
-
Using Alamofire with Swift 2.0
Shows how to import Alamofire manually, configure project dependencies and make network requests in a Swift 2.0 environment. Screenshots identify the project-linking settings, preserving an early framework integration and usage workflow.
-
Integrating Alipay friend sharing in three minutes
Walks through app registration, SDK import, URL Scheme configuration and callbacks for sharing to Alipay friends. It distinguishes the data objects for text, image and web messages, and records checks for installation detection and authentication failures.
-
Getting started with XMPP, step by step
Records the initial integration of XMPP chat: importing dependencies, connecting to Openfire with user information, handling registration and sign-in authentication, and processing message callbacks. Client-side code accompanies the connection and messaging workflow.
-
Reading iOS contacts and sending SMS invitations
Introduces a small wrapper for a friend-invitation workflow: reading device contacts and opening the SMS composer. It lists the AddressBook, AddressBookUI and MessageUI dependencies and provides the LBContacts example project.
Tools & releases
Reading notes & full list-
Practical Automated Testing for iOS
Compares unit tests with UI automation and introduces XCTest, Quick, Nimble, KIF, and Appium. It discusses waiting, stubs and mocks, command-line execution, and testable code structure as foundations for maintainable tests.
-
Xcode 8 and iOS 10 Compatibility Notes
Collects migration notes on notifications, ATS, privacy permissions, and interface changes in Xcode 8 and iOS 10. It also records issues involving logging, fonts, list performance, plugins, and xib warnings, with links to official documentation.
-
Adding iOS 10 Push Notification Extensions in Xcode 8
Records the process of adding iOS 10 notification extensions to an existing app in Xcode 8. It covers push capabilities, signing, Swift versions, architecture settings, and debugging and submission issues for Service and Content extensions.
-
What's new in iOS 10: SiriKit
Introduces SiriKit integration following WWDC 2016, from creating an Intents Extension to implementing intent handling and its interface. It explains how a spoken request is interpreted and passed to an app extension for the relevant response.
-
Prompting users to review an iOS app
Introduces the LBToAppStore review-prompt wrapper, using the app version, elapsed days and the user's previous choice to decide when to show a dialog. The response either opens the store or postpones the reminder, illustrating an early review-request workflow.
-
Apple's Xcode testing documentation in Chinese, part 2
Continues the Chinese translation of Apple's testing documentation with code coverage, command-line testing, Xcode Server continuous integration and UI test recording. It also discusses structuring testable code and migrating from OCUnit to XCTest.
-
Apple's Xcode testing documentation in Chinese, part 1
A Chinese translation of earlier Apple testing documentation covering XCTest project setup, test classes and methods, the test lifecycle, performance tests and UI tests. The test navigator illustrates running cases and inspecting their results.
-
Publishing a library to CocoaPods
Records the process of publishing an open-source library: preparing the GitHub project, registering with trunk, writing a podspec, checking versions and tags, validating and submitting. It also explains commonly used specification fields.
-
Xcode development tips from a SwiftGG discussion
Collects Xcode techniques from a SwiftGG discussion: exception, symbolic and test-failure breakpoints; inspecting and changing variables during debugging; Quick Look; and reusable code snippets.
-
Restoring old Xcode plug-ins after a version update
Documents historical fixes for plug-ins that stopped loading after an Xcode update or an accidental Skip Bundles selection. It checks compatibility UUIDs, edits plug-in Info.plist files and resets the loading choice.
-
Preparing an iOS app for Apple Pay
Records early Apple Pay project setup: enabling the capability, creating a Merchant ID and configuring payment-request properties. It also lists questions about country and currency codes; the demonstrated result comes from the simulator identified in the original article.
-
Bison's collection of solutions to common Git errors
Collects index-lock errors and warnings about Git's default push behaviour, with error screenshots and the configuration commands used at the time. It supports reviewing troubleshooting by error type; inspect the current repository state before applying a command.
-
Integrating a Baidu Mobile SSP launch ad in one minute
Records the historical integration of Baidu Mobile SSP splash ads, from platform registration and SDK import to system dependencies, compiler options and launch-time delegate callbacks. It follows the main steps for loading an ad during app startup.
-
Practical lessons from localising an iOS app
Reviews translation-file organisation, button-label length, language-region identifiers and localised image names. It focuses on how the language identifier changes in iOS 9 affected logic that detected Chinese in a multilingual project.
-
Detecting device locking in an iOS app
Records SpringBoard lock-notification handling used to investigate a failure in an embedded game when the device locked. It preserves the troubleshooting approach and callback code; the conditions under which those interfaces may be used need separate verification.
-
Packaging an iOS static library as an .a file
Records a workflow for building separate device and simulator static libraries in Xcode, inspecting their architectures with lipo and combining the .a files. It explains matching the target platform during testing and checking the resulting library.
-
An illustrated guide to implementing iOS in-app purchases
An early end-to-end integration guide covering agreements, in-app purchase products, sandbox accounts and client code. It follows StoreKit product requests, the payment queue, transaction-state handling and receipt validation through the setup process.
-
iOS App Store rejection cases and solutions: an ongoing record
A collection of App Review issues involving crashes, background modes, third-party sign-in, in-app purchases and user content, with the responses used at the time. These historical rules and individual cases help identify categories of review problems.
-
Installing and using CocoaPods for iOS development
Starting with Ruby and CocoaPods installation, this article explains how to find dependencies, write a Podfile, install pods and open the generated workspace. It also records a fix for header completion, illustrating an early iOS dependency-management workflow.
-
Disabling and dimming third-party sign-in buttons when the app is not installed
Uses QQ and WeChat sign-in buttons to show how installation checks can determine whether a button is hidden, disabled or dimmed. It records the interface treatment used when the corresponding third-party app was unavailable.
Audio & video development
Reading notes & full list-
Camera and Microphone Capture with FFmpeg-iOS
First uses FFmpeg device input support to list cameras and microphones, then presents a native iOS camera-capture example. The two approaches illustrate media-device enumeration and the basic configuration of a system capture session.
-
A Simple Streaming Wrapper for FFmpeg-iOS
Builds on the preceding FFmpeg articles to set up a local nginx streaming test environment. Server configuration, a client-side streaming wrapper, and playback in VLC connect the process of sending encoded data with checking the resulting stream.
-
H.264 Decoding with FFmpeg-iOS
Starts by importing FFmpeg-iOS and configuring header search paths, then traces opening media, finding a video stream, initializing the decoder, reading packets, and releasing resources. A wrapper example brings the H.264 decoding steps together.
-
Building FFmpeg-iOS on a Mac
Records preparing gas-preprocessor and yasm on a Mac, then running the FFmpeg-iOS build script. It explains script locations, dependency installation, and output directories to prepare libraries for the later decoding examples.
-
Integrating ijkplayer for live video on iOS
Records downloading the source, initialising dependencies, compiling FFmpeg, packaging IJKMediaFramework and adding it to an iOS project. The focus is on the role of each directory and build step in the ijkplayer integration.
Web & development notes
Reading notes & full list-
WeChat Mini Programs from Scratch, Part 3
Connects an article list to a network request, reads the response, updates the page with setData, and adjusts WXML field bindings. It also records the limitations encountered at the time with image URLs and HTML5 detail pages.
-
WeChat Mini Programs from Scratch, Part 2
Adds an article detail page to the existing list, using navigator for navigation and parameters. It then adjusts spacing, image placement, and text layout in WXSS to refine the list into the intended page design.
-
WeChat Mini Programs from Scratch, Part 1
Builds an IT Blog mini program from an iOS developer's perspective. It explains the roles of app.json, app.js, WXML, and WXSS, configures a TabBar, and uses templates and list rendering to display article data.
-
Setting Up React Native for iOS Development on a Mac
Records a React Native setup on macOS: installing Homebrew, Node.js, watchman, and flow, creating a project, opening the iOS project, and refreshing code in the simulator.
-
JavaScript and Native iOS Interaction with JavaScriptCore
Compares early UIWebView URL interception with JavaScriptCore. Using JSContext, it introduces executing JavaScript from native code, registering native methods, and passing data between the two environments.
-
A beginner developer's review of 2015
Reflects on the author's job search, development projects and self-directed learning in 2015. Starting a technical blog, learning Swift, releasing open-source UI components and meeting other developers provide the personal context for this early stage of growth.
-
Helping Baidu discover a GitHub Pages blog: a historical workflow
Records mirroring a GitHub Pages blog to GitCafe Pages, using SourceTree to clone and push branches, bind a domain and configure regional DNS. The workflow aimed to improve access and search indexing in mainland China at the time.
-
A technical blog can be more than a website
Records an experiment in wrapping a personal technical blog as an iOS app. UIWebView displays the home and category pages and handles loading callbacks, while search and interaction-stutter issues remain documented as unresolved at the time.
-
Using UIWebView: techniques and notes
Collects common UIWebView settings for loading web pages inside a native interface, including transparent backgrounds, scaling, phone-number detection and JavaScript interaction. It also discusses the layout and communication costs of a cross-platform approach.
No matching articles
Try a shorter term or remove a version number. You can also clear the search and browse by topic.