【51CTO translation】Each version update of Xcode focuses on bringing more powerful tools to developers to help them build applications more smoothly. In the Xcode 6 version released this year, developers continue to welcome more new ways of software design and construction. In today's tutorial, we will give an overview of the new and improved features in Xocde 6, and introduce how you should apply them to your own development work.

1. Playgrounds

At this year's WWDC conference, Apple officially announced Swift, a new programming language for software development on Apple mobile devices. To coincide with the birth of the new language, Xcode 6 added a new feature called Playgrounds, which is actually an interactive workspace where developers can write Swift code and get real-time feedback on the running effect without running it on a device or simulator. This is undoubtedly a great addition to Xcode, as you can now quickly and easily master the real-time running effect in an experimental way before officially adding your code results to the main code base.

2. Interface Builder

Another major theme of this year's WWDC conference is to build adaptive applications. Instead of building applications for specific screen sizes, Apple now encourages developers to create applications that can ignore the actual screen size and automatically adapt to the platform on which they are running.

The move actually stems from Auto Layout, which was originally born in iOS 6 and its subsequent versions, which allowed developers to create applications that can run on both 3.5-inch and 4.0-inch screens. Now this mechanism has been further improved, and iOS developers can now create applications that run directly on all supported iPhone platforms, including the new 4.7-inch iPhone 6 and 5.5-inch iPhone 6 Plus - even iPad can use the same code base.

Interface Builder has undergone a series of major changes to support the development of such adaptive applications. Other new features have also been added to improve the user interface design process. Let's take a look at the changes in detail.

Size Classes

Size classes are responsible for defining the canvas size used by layout schemes. These classes allow developers to specify how the application's user interface delivers the available display range based on changes in view controllers. With the help of Size Classes, we can build an application with a unified display template. In contrast, in the past, developers needed to design two independent display templates, one for iPad and the other for iPhone.

A Size Class defines a relative quantity within the display area, such as the display height (i.e., vertical dimension) or the display width (i.e., horizontal dimension). Currently, Xcode provides two size classes, compact and regular. For example, an iPhone has a compact width but regular height in portrait mode. An iPad has regular width and height in both portrait and landscape modes.

But you should note that size classes do not necessarily map to a particular display mode of a device. For example, an iPad can use only a small area of ​​the screen to provide views similar to the iPhone layout style (i.e., compact horizontally and regular vertically) while also using the natural style layout inherent to the large screen size of a tablet device (i.e., regular horizontally and regular vertically).

You adjust the size classes using the Size Classes controls at the bottom of the Interface Builder canvas, near the layout toolbar. Interface Builder starts with any width and any height size classes, which you can use to position and position UI components based on the actual screen size and landscape/portrait display mode of different devices. Then, when the available screen size changes, you use a different size class to update the position of components in the UI to provide a layout that better suits your needs.

Adaptive transition type

The adaptive transition types provided by Xcode 6 are more suitable for use with the new adaptive layout because they can provide different view solutions based on the environment in which they are running. For example, using Show Detail in Split View on iPad will replace Detail, but on iPhone, the same operation will push Detail to Master. Some old transition types, such as push and modal, are now deprecated.

Real-time rendering

The Interface Builder canvas is much more interactive than before. In the past, you had to actually run your app to see changes to custom objects, custom fonts, and component positions. Now, you can select a custom font through the Interface Builder font picker and display it directly in the Interface Builder canvas.

You can even create custom objects and render them in the Interface Builder canvas. To do this, you need to create a custom framework, add your custom class to it, and mark it with the @IBDesignable tag (IB_DESIGNABLE in Objective-C). This will make Interface Builder aware that this is a class that can display custom content in the canvas.

In addition to being able to view custom objects in Interface Builder, you can now annotate properties with the @IBInspectable tag so that they appear in Interface Builder's inspect menu. From there, you can edit the property just like you would any other property in the view. In other words, you no longer have to annotate a class as inspectable to make it an inspectable property.

You can also specify design time in pure code. For example, you can use this method to pre-populate sample data into the view to get a more accurate feel of the interface. To do this, you need to override the prepareForInterfaceBuilder method. In addition, you can also use #if TARGET_INTERFACE_BUILDER to add or remove selected code from the final Interface Builder rendering effect view.

Preview Editor

Preview Editor now allows you to view multiple previews on different simulated devices one by one. In addition to being able to directly observe how the application runs on different devices, you can also change the vertical or horizontal display mode of each device through settings. With the help of this new feature, we can more easily preview the user interface of the application on different devices and their display modes without actually running it.

3. Game Development

Apple has added new gaming technologies to Xcode 6 and iOS 8, called SceneKit and Metal. SceneKit has been available on OS X and is a 3D scene rendering tool. Metal is a framework that can be used to create highly optimized graphics rendering and computing tasks because it can interface with the A7 and A8 GPUs in a low-cost way.

SpriteKit has also been improved on many levels, including per-pixel physics balance, physics regions, general mobility and constraints, materials, lighting, and shadows.

Another important new feature in SpriteKit is the SpriteKit Level Editor, which allows us to build scenes in an intuitive way. Just as you can create user interfaces in Interface Builder without writing any code, the SpriteKit Level Editor can help us easily create SpriteKit games in the same way.

4. OS X Development

Storyboard

Storyboards have also been introduced to the OS X development process. Just like in the iOS development environment, Storyboards allow us to build our own view layouts and combine these views with a variety of different types of transition animations. However, as of the date of writing, some features - including Storyboards - are still not available for OS X development in Xcode (6.0.1). I believe that the situation will be changed when the OS X Yosemite version is released.

Gesture Recognition

Gesture recognition is now available in AppKit, and its use is exactly the same as the iOS application development process. You can view the available gesture operation types in the Object Library in Interface Builder.

5. Localization

Localization works very differently in Xcode 6 than in previous versions. You can now export all your localizations to XLIFF, an industry standard implemented by many translation services. Once you have the translations, you can import them and Xcode will merge the new content into your project. By the way, you should create an XLIFF file for each language your app supports.

You can now preview all localizations without having to change the local options on the device or simulator through settings. To do this, select Product 〉Scheme 〉Edit Scheme, then select Run and click the Options tab. You can now select the language you want from the Application Language menu. Xcode also provides Double Length Pseudolanguage projects, so you can still test even if you haven't added any other languages. After running the application, you can view the corresponding localizations.

Furthermore, we can also view localized content without actually running our application. To do this, you need to use the Preview Editor to switch between the different languages ​​supported by the application. The default language is displayed in the lower right corner of the editor. When we click on it, we can see a list of available languages. Once again, if you want to test without adding languages, you need to use the Double Length Pseudolanguage mechanism.

6. iOS Simulator

Naming the device

Xcode 6 now offers simulator naming, so developers can distinguish specific devices with names like "iPhone 5s" instead of using generic names like 64-bit iPhone Retina as in the past.

Simulator size is adjustable

Now you can choose the device type you want from the resizable iPhone and resizable iPad options. These two options allow you to specify the width, height, and screen size of the simulator. This way, you can more easily test how your application runs on Apple's current devices and future devices without having to download different simulator options for each device.

Custom configuration of simulator

In the new iOS Simulator, you can combine data with configuration settings. Specifically, you can run one configuration and its associated data for a specific version of an application, and another configuration and its associated data for another version. This means you can simulate the experience of multiple users on the device. Each user has their own independent data and configuration.

7. HomeKit Accessory Simulator

The HomeKit framework allows your application to communicate with and control other connected accessories in the user's home. In the current Xcode 6 beta version, the HomeKit accessory simulator already exists as an inherent part, but it is still one of the functions of Hardware I/O Tools in Xcode. You can click here to download the framework from the iOS Dev Center.

8. Debugging

View debugging tools

Xcode 6 provides real-time view debugging, which greatly simplifies the debugging process of the application user interface. Now developers can pause the running application and analyze the current interface in 3D view mode. The view debugging tool can display the current view hierarchy and Auto Layout settings. When you select a view, you can check its properties in the inspection tool or jump to the corresponding code in the assistant editor. With this powerful support, you can solve many problems that used to be a headache - such as Auto Layout conflicts, seeing why a view is hidden or collapsed, etc.

To start the Live View debugging tool, we first need to start our application and then click the Debug View Hierarchy button on the debug toolbar.

At this point our application will pause and the entire user interface will be presented in 3D visualization. We can drag anywhere in the canvas to rotate the view.

You can use the buttons below the canvas to switch between various view states.

From left to right the buttons are:

• Show Collapsed Content: This option is used to hide or show the collapsed content in the selected view.
• Show Constraints: This option displays the Auto Layout constraints for the selected view.
• Reset Viewport: This option will reset the canvas to its default state.
• Adjust the view mode: This mode allows you to choose how you want to view the view. You can choose to see only the view border, the view content, or both.
• Zoom out, Actual size, Zoom in: Allows you to adjust the size of the view.

Quick Look

Quick Look first appeared in Xcode 5. Its function is to help you view the contents of a specific object during debugging. Quick Look supports a variety of common object types, including images, Bezier curves, and map locations.

In Xcode 6, this feature has been improved to support two new object types: views (UIView and NSView) and custom objects. To enable Quick Look to recognize custom objects, you need to add the debugQuickLookObject method to your custom class.

Enhanced queue debugging mechanism

The Debug Wizard records and displays the most recently executed blocks and queued blocks. You can use this to see where your queued blocks are located and to examine the exact settings for execution. You can enable block debugging by selecting the Debug > Debug Workflow > Always Show Pending Blocks in Queues menu option.

Debugging Meters

The debug meter is used to provide various information related to the application's resource usage during debugging. Xcode 6 has upgraded the meter, which can now analyze the new Metal framework and iCloud for supporting documents in Cloud and CloudKit in a graphical way.

In addition to the above improvements, Xcode 6 also introduces two new debug meters, one for network and one for disk activity.

The network activity meter is designed to show the amount of data sent and received by our application, and also provides a list of open connections. You can monitor network usage by viewing historical time records to help you find when and why network usage spikes or network failures occur.

The Disk Activity Meter displays real-time information about the application's disk read and write operations. It also provides information about all open files. Disk I/O activity is delivered as a historical timeline so you can monitor it.

9. Asset Catalog

The asset catalog now supports size classes. This means you can easily provide specific image assets for different size classes, so your UI has both regular and compact height and width designs.

The original asset catalog only supported PNG images, but in Xcode 6, the new version can support two new formats: JPEG and PDF vector images.

10. Startup Image

You can use XIB or storyboard as your application launch image. The operating system will generate the necessary launch images for our application. With this feature, you no longer have to provide separate assets for the launch image, and you can also design it in Interface Builder.

To set a XIB or storyboard as your app's launch image, we need to select the corresponding project in the Project Navigator and choose its target from the target list. Under the General tab, select the App Icons and Launch Images option and select the correct file from the Launch Screen File menu tab.

11. Testing

Asynchronous Testing

The XCTest framework has also added a variety of new APIs for testing asynchronous code. This feature is implemented through the expectation object, XCTestExpectation, which describes the expected event. XCTestCase contains a new API that always waits for the expected condition to be met and sets a timeout for it. When all events are actually executed or the timeout is reached, the completion handler will be called. It is important to emphasize that this API can wait for multiple asynchronous events at the same time. Now you can more easily test the interactions in the system that are executed asynchronously, such as file I/O and network requests.

Performance Testing

The enhanced XCTest framework can now quantify the performance of each component of the application. Xcode is responsible for running performance tests and allows you to define a set of baseline performance indicators. Each subsequent test will be compared with the baseline performance and show the changes over time, and finally highlight the problem areas to remind you of the performance degradation that may be caused by the submitted code. If the average performance indicator is significantly different from the baseline level, it means that the performance test has failed. For developers, it is an ideal solution for detecting performance degradation in applications.

Profile test

With the introduction of performance testing, we now have the ability to profile tests in Instruments. You can select a test suite or a group of test suites for the profile, and then further investigate and analyze in Instruments to understand why the test failed and ultimately find the root cause of the performance regression.

12. Instruments

The Instruments user interface has also been updated, with a new template selection that lets you choose your instrument, target, and starting point for the profiling workflow.

We can see a new template called Counters, which combines with Events to drill down and examine individual CPU events. You can even specify formulas for measuring event aggregates and even ratios.

In Xcode 6, Instruments also provides support for Swift, and you can use it to configure application extensions. Instruments also provides support for simulator configurations and treats the configuration scheme as the device itself, which greatly simplifies the mechanism for starting or attaching processes in the simulator.

Summarize

Apple is still constantly improving its developer tools, and this is what Xcode strives to achieve in every major version. Xcode 6 goes a step further than its predecessor, striving to provide developers with tools that can improve their workflow and make the entire development process smoother.

Original link:

http://code.tutsplus.com/articles/getting-up-to-speed-with-xcode-6--cms-22287

Getting Up to Speed ​​With Xcode 6

Nuka-Cola Translation