With this in mind, I created an iOS app called “SOMATO” that allows us to browse 100 photos in a second at maximum.

If you have 1,000 photos, you can view them in 10 seconds.

Well, to be honest, the 100 images/second speed is more for impact than anything else, but surprisingly, even when the speed is around 20 images/second, you can still feel nostalgic and soak in the memories. It’s free, so if you’re interested, please download it and give it a try.

‎High Speed Photo Album SOMATO

(Available on iPhone, iPad, and M1 Mac)

This article describes the implementation of this application.

Overview

In fact, Somato is not particularly technically advanced.

To put it bluntly, it just acquires images with Photos (PhotoKit) and displays them with UICollectionView.

The first prototype took less than an hour to build. I didn’t have to do anything special, just a straightforward implementation, and I was like, “Hey, it’s displaying in less than 1/100th of a second…! That’s what I thought. (When I made an app with a similar concept about 10 years ago, it didn’t work like this due to the limitations of device performance.

But of course, it was not so easy when it came to making a proper product…

Memory Issues

In the first prototype I made, I loaded all the 500 images I had in my iPhone as UIImage first (before starting to display them).

Since the size of the images should be large enough to be displayed in three rows (375x375 on an iPhone 12 mini), the memory usage was still not significant.

However, this is a different story when you have more than 10,000 images on your iPhone. In fact, the designer I worked with had 16,000 photos and videos on his iPhone. No matter how small the size, 10,000 images cannot be stored in memory as UIImage.

Furthermore, a single row display would require higher resolution image data.

The concept of the app is to be able to look back at a large number of photos at high speed, so I can’t just set a limit of “up to 1,000 albums”. 10,000 or 1,000,000 photos need to be able to be displayed at high speed without eating up memory.

Multi-threaded problem

Due to the above limitation of memory usage, it is necessary to cache a certain number of images in memory and display them, while discarding the old cache and reading them in the background thread at a pace of 1/100th of a second.

So, in addition to the main thread for drawing the screen, multi-threaded processing is required: a thread for managing the memory cache, a thread for retrieving images from local or iCloud, and so on.

It is also important to note that the cache should be in a Serial Queue to unify access, and the image acquisition should be in a Concurrent Queue for parallel processing.

The problem of video frame extraction processing

Since the concept is to “browse a large number of photos at high speed”, we also want to look back at videos at high speed, so Somato extracts a frame from the video every n seconds and plays it at high speed just like a single photo. (This is quite emotive.)

This video processing is even more difficult, because the process of extracting frames involves video decoding, so no matter how much you read ahead while displaying 1/100th of a second, you will not be able to finish in time.

Therefore, it is necessary to cache the extracted frames, and then load the necessary portions into memory while discarding them.

The Problem with iCloud

iCloud was even more egregious. There were two main problems

1. Problems with the loading speed from iCloud
2. PhotoKit’s Internal Error problem

The first was a problem with downloading over the network.

For the first one, when downloading over the network, it naturally takes much longer than loading from the local network, so when doing PHImageManager.default().requestImage, first getting low-resolution thumbnail-level images with:

let options = PHImageRequestOptions()
options.deliveryMode = .fastFormat

then getting the necessary size images from iCloud and caching the files. These are done in a background thread while playing at 100 images/second.

However, the more complicated and inevitable problem for third-party developers is #2. This is caused by the iCloud sync status of your system. If you go to the Settings app, turn off Photos > iCloud Photos, wait 5 minutes (after the data is deleted), turn it back on, and then go to the standard Photos app, you will see that iCloud shared albums and other photos do not appear.

Immediately after enabling iCloud sync, or when you haven’t viewed the iCloud album (photos) in question for a long time in the standard Photos app, the OS hasn’t even been able to acquire thumbnail resolution images yet, and if you try to access the photos in the Photos framework at this time, it will cause the Internal Error.

[PhotoKit] Error: Unknown internal error

Conclusion

I wrote about the implementation of a viewer application that displays photos at high speed.

It was “easy to make” with about 500 photos, but when I started to consider about 16,000 photos, video support, iCloud support, etc., it was unexpectedly difficult.

There may not be many cases where you want to display images at 1/100th of a second, but

• Fetching images with Photos at high speed
• To save memory (not proportional to the number of images)
• Extracting frames from a video at high speed

I think this kind of implementation itself is actually rather useful in general.

Here is the way:

guard let url = Bundle.main.url(/service/forresource: name, withExtension: "usdz") else { fatalError() }
let mdlAsset = MDLAsset(url: url)
let scene = SCNScene(mdlAsset: mdlAsset)

That’s it. Anything is not special for the `usdz` format.

You will need

import SceneKit.ModelIO

to initialize SCNScene from MDLAssset.

This implementation is available on iOS 10 or greater because USD format has been supported since iOS 10. You don’t need to wait for iOS 12.

MDLAsset currently supports following formats:

• .abc
• .usd .usda .usdc
• .usdz
• .ply
• .obj
• .stl

It’s supported on A8 or newer devices.

It can achieve better performances because it’s pre-compiled at build-time. Existing way (GLSL or CIKernel Language) are compiled at run-time.

How to implement?

Followings are the new APIs added to CIKernel:

public convenience init(functionName name: String, fromMetalLibraryData data: Data) throws

public convenience init(functionName name: String, fromMetalLibraryData data: Data, outputPixelFormat format: CIFormat) throws

Here is a simple MSL implementation for CIColorKernel:

#include <metal_stdlib>
using namespace metal;
#include <CoreImage/CoreImage.h> // includes CIKernelMetalLib.h

extern "C" { namespace coreimage {

    float4 myColor(sample_t s) {

        return s.grba;
    }

}}

Let’s save it as kernel.metal or something (Any name is OK, but the extention should be .metal`).

A CIColorKernel which uses the shader function can be initialized using the new API:

let url = Bundle.main.url(/service/forresource: "default", withExtension: "metallib")!
let data = try! Data(contentsOf: url)
let kernel = try! CIColorKernel(functionName: "myColor", fromMetalLibraryData: data)

So, a CIFilter subclass which has the custom kernel can be implemented like this:

import CoreImage

class MetalFilter: CIFilter {

    private let kernel: CIColorKernel

    var inputImage: CIImage?

    override init() {
        let url = Bundle.main.url(/service/forresource: "default", withExtension: "metallib")!
        let data = try! Data(contentsOf: url)
        kernel = try! CIColorKernel(functionName: "myColor", fromMetalLibraryData: data)
        super.init()
    }

    required init?(coder aDecoder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }

    func outputImage() -> CIImage? {
        guard let inputImage = inputImage else {return nil}
        return kernel.apply(extent: inputImage.extent, arguments: [inputImage])
    }
}

The custom filter can be used like this:

let filter = MetalFilter()
filter.inputImage = inputImage
let outputImage = filter.outputImage()

That’s it!

Build Settings

OK, now we can build the project. Let’s run it on your device!

+[CIKernel kernelWithFunctionName:fromMetalLibraryData:outputPixelFormat:error:] Function 'myColor' does not exist.

Hmm, but it says myColor does not exist. But it exists…

I found the solution here:

• kernelWithFunctionName:fromMetalLibraryData:error: — CIKernel | Apple Developer Documentation

We need to specify some options in the build settings:

• Specify -fcikernel flag in the Other Metal Compiler Flags option
• Add a user-defined setting with a key called MTLLINKER_FLAGS with a value of -cikernel

It works!

Apple provides samples for the MPSCNN (MPSCNNHelloWorld / MetalImageRecognition), and I integrated it into my sample code collection repo:

shu223/iOS-10-Sampler

In these sample apps, pre-trained model parameters (weight / bias) are used in the app, and those files are named xxxx.dat.

What kind of file is this? Is this something special by Apple? Can MPS CNN use only this format? What format is the content?

In this article, I write about the model format of MPS CNN.

File format

The `xxxx.dat` files which are included in samples such as Apple’s MPSCNNHelloWorld or MetalImageRecognition are ordinary binary files. Thus those are NOT MPSCNN or Apple proprietary / exclusive.

This file can be loaded to memory without any dependencies on Metal or MetalPerformanceShaders as follows:

let fd = open( filePath, O_RDONLY, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH)
assert(fd != -1, “Error: failed to open output file at \””+filePath+”\” errno = \(errno)\n”)

guard let hdr = mmap(nil, size, PROT_READ, MAP_FILE | MAP_SHARED, fd, 0) else {
    close(fd)
    return nil
}

Then, to use this with MPSCNN,

Casting UnsafeMutableRawPointer to UnsafePointer<Float>,

let p = UnsafePointer<Float>(hdr.assumingMemoryBound(to: Float.self))
assert(p != UnsafePointer<Float>(bitPattern: -1), “mmap failed with errno = \(errno)”)

and pass this pointer to the initializer of MPSCNNConvolution or MPSCNNFullyConnected.

public init(device: MTLDevice, convolutionDescriptor: MPSCNNConvolutionDescriptor, kernelWeights: UnsafePointer<Float>, biasTerms: UnsafePointer<Float>?, flags: MPSCNNConvolutionFlags)

MPSCNNConvolution or MPSCNNFullyConnected copies the parameters when it’s initialized, so you can release the data loaded on memory and close the file.

munmap(hdr, Int(size))
close(fd)

These are also independent of Metal or MetalPerformanceShaders, very generic methods for files or memory.

In conclusion, any file format can be used, as far as it can be read by the iOS app.

Which tools can be used to train the models?

In Apple’s MPSCNNHelloWorld and MetalImageRecognition, they say the parameters are trained using Google’s TensorFlow.

Another article says they used Chainer or Kelas for the training, and ported the parameters to iOS using a file format called HDF5.

Weight Ordering

Although any file format can be used for the parameter files, there is a rule for the content.

Let’s look at the initializer of MPSCNNConvolution again:

public init(device: MTLDevice, convolutionDescriptor: MPSCNNConvolutionDescriptor, kernelWeights: UnsafePointer<Float>, biasTerms: UnsafePointer<Float>?, flags: MPSCNNConvolutionFlags)

The weights in CNN should be a 4D tensor (Input Channels, Kernel Width, Kernel Height, Output Channels), but there is no argument to tell the order of the 4D tensor in the initializer.

So, we have to pass the weights 4D tensor with following order:

weight[ outputChannels ][ kernelHeight ][ kernelWidth ][ inputChannels ]

For example, to read it with for loop, the code is like this:

for o in 0..<outputChannels {
    for ky in 0..<kernelHeight {
        for kx in 0..<kernelWidth {
            for i in 0..<inputChannels {
                let index = Int(((o * kernelHeight + ky) * kernelWidth + kx) * inputChannels + i)
                print(String(format: "\(index): %.3f", kernelWeights[index]))
            }
        }
    }
}

(reference: MPSCNN Weight Ordering — Stack Overflow)

Exporting from TensorFlow

import tensorflow as tf

// …

w_conv1 = weight_variable([5, 5, 1, 32])
b_conv1 = bias_variable([32])

// …(train)

Assume that you get trained weights/bias parameters using TensorFlow with above code.

To export to files named “weights_xxx.dat” or “bias_xxx.dat” respectively to use those in MPSCNN, you can do it as follows:

with open('weights_conv1.dat', 'w') as f:
    w_conv1_p = tf.transpose(w_conv1, perm=[3, 0, 1, 2])
    f.write(session.run(w_conv1_p).tobytes())
with open('bias_conv1.dat', 'w') as f:
    f.write(session.run(b_conv1).tobytes())

As for weights for Fully-Connected layer, the code will be as follows:

with open('weights_fc1.dat', 'w') as f:
    w_fc1_shp = tf.reshape(w_fc1, [7, 7, 64, 1024])
    w_fc1_p = tf.transpose(w_fc1_shp, perm=[3, 0, 1, 2])
    f.write(session.run(w_fc1_p).tobytes())The points are:

• Open the file using `open()` as “write” mode.
• Re-order the weights 4D tensor.
• As for a fully connected layer, reshape the 2D tensor to 4D, then transpose it.
• Write the binary data to the file using `write()` or `tobytes()`.

Wrap up

• Any file format can be used, as far as it can be read by the iOS app.
• The order of the trained params’ 4D tensor should be:

weight[ outputChannels ][ kernelHeight ][ kernelWidth ][ inputChannels ]

• As far as conditions above are satisfied, any tools / libraries can be used such as TensorFlow, Chainer, etc.

https://github.com/shu223/pulsator

It’s good for indicating:

• locations on map
• beacons of iBeacon
• Bluetooth Low Energy (BTLE) devices
• or other “Radio Wave” related devices

It can be installed in an instant, so I use it on not only my client works, but also small prototypes, or works in hackathons.

It’s written in Swift, and the license is MIT.

How to use?

It can be used with only 3 lines of code.

1. Initialize

let pulsator = Pulsator()

2. Add to your view’s layer

view.layer.addSublayer(pulsator)

3. Start animating

pulsator.start()

Customizations / Demo

You can customize the radius, color, number of pulses, etc. Please refer to the demo project or Playground which are in the repository.

Demo

• Example/PulsatorDemo.xcodeproj

Playground

• Pulsator.playground

Browser Demo

You can try also on browsers.

PulsatorDemo

Installation

It supports CocoaPods and Carthage.

CocoaPods

Add into your Podfile.

pod “Pulsator”

Carthage

Add into your Cartfile.

github “shu223/Pulsator”

Showcase

I used the Objective-C version of this library “PulsingHalo” in many client works, open source projects and so on.

WHILL

Moff

BONX

Waves which indicate “talking”

iOS-9-Sampler

Indicates the locations and strengths of forth touches.

Inside of Pulsator

Pulsator is implemented using Core Animation.

CAReplicatorLayer

Pulsator is a subclass of CAReplicatorLayer.

public class Pulsator: CAReplicatorLayer

CAReplicatorLayer is a layer which creates `instanceCount` copies of its sublayers, so Pulsator uses it to generate multiple pulses.

CAAnimationGroup

The animation for each pulse consists of scale animation + opacity animation, and Pulsator use those animations combining with CAAnimationGroup.

let scaleAnimation = CABasicAnimation(keyPath: “transform.scale.xy”)
// some setup
 
let opacityAnimation = CAKeyframeAnimation(keyPath: “opacity”)
// some setup
 
animationGroup = CAAnimationGroup()
animationGroup.animations = [scaleAnimation, opacityAnimation]

About me

I’m an iOS freelancer in Japan, welcome works from abroad.

You can check my past works here: My Profile Summary — Medium

Other contacts:

• Twitter
• Facebook
• LinkedIn

import

objc

@import CoreBluetooth;

swift

import CoreBluetooth

Central Manager

Initialize

Adopt protocol and define properties.

objc

@interface SomeClass () <CBCentralManagerDelegate>
@property (nonatomic, strong) CBCentralManager *centralManager;
@property (nonatomic, strong) CBPeripheral *peripheral;
@end

swift

class ComeClass: SomeSuperclass, CBCentralManagerDelegate {
    var centralManager: CBCentralManager!
    var peripheral: CBPeripheral

Initialize CBCentralManager.

objc

self.centralManager = [[CBCentralManager alloc] initWithDelegate:self queue:nil];

swift

centralManager = CBCentralManager(delegate: self, queue: nil)

Scan

Receive the update of central manager’s state. **Required**

objc

- (void)centralManagerDidUpdateState:(CBCentralManager *)central {
    NSLog(@”state:%ld”, (long)central.state);
}

swift

func centralManagerDidUpdateState(central: CBCentralManager) {
    print(“state: \(central.state)”)
}

Start scanning.

objc

[self.centralManager scanForPeripheralsWithServices:nil options:nil];

swift

centralManager.scanForPeripheralsWithServices(nil, options: nil)

Receive the results of scan.

objc

- (void)   centralManager:(CBCentralManager *)central
    didDiscoverPeripheral:(CBPeripheral *)peripheral
        advertisementData:(NSDictionary *)advertisementData
                     RSSI:(NSNumber *)RSSI
{
    NSLog(@”peripheral：%@”, peripheral);
}

swift

func centralManager(central: CBCentralManager,
    didDiscoverPeripheral peripheral: CBPeripheral,
    advertisementData: [String : AnyObject],
    RSSI: NSNumber!)
{
    print(“peripheral: \(peripheral)”)
}

Stop scanning.

objc

[self.centralManager stopScan];

swift

centralManager.stopScan()

Connect

Start connecting.

objc

[self.centralManager connectPeripheral:peripheral options:nil];

swift

centralManager.connectPeripheral(peripheral, options: nil)

Receive the result of connecting.

objc

// Called when it succeeded
- (void)  centralManager:(CBCentralManager *)central
    didConnectPeripheral:(CBPeripheral *)peripheral
{
    NSLog(@”connected!”);
}

// Called when it failed
- (void)        centralManager:(CBCentralManager *)central
    didFailToConnectPeripheral:(CBPeripheral *)peripheral
                         error:(NSError *)error
{
    NSLog(@”failed…”);
}

swift

// Called when it succeeded
func centralManager(central: CBCentralManager,
    didConnectPeripheral peripheral: CBPeripheral)
{
    print(“connected!”)
}

// Called when it failed
func centralManager(central: CBCentralManager,
    didFailToConnectPeripheral peripheral: CBPeripheral,
    error: NSError?)
{
    print(“failed…”)
}

Discover services & characteristics

Adopt CBPeripheralDelegate protocol.

objc

@interface SomeClass () <CBCentralManagerDelegate, CBPeripheralDelegate>

swift

class SomeClass: SomeSuperclass, CBCentralManagerDelegate, CBPeripheralDelegate {

Start discovering services.

objc

peripheral.delegate = self;
[peripheral discoverServices:nil];

swift

peripheral.delegate = self
peripheral.discoverServices(nil)

Receive the result of discovering services.

objc

- (void)     peripheral:(CBPeripheral *)peripheral
    didDiscoverServices:(NSError *)error
{
    if (error) {
        NSLog(@”error: %@”, error);
        return;
    }
 
    NSArray *services = peripheral.services;
    NSLog(@”Found %lu services! :%@”, (unsigned long)services.count, services);
}

swift

func peripheral(peripheral: CBPeripheral, didDiscoverServices error: NSError?)
{
    if let error = error {
        print(“error: \(error)”)
        return
    }

    let services = peripheral.services
    print(“Found \(services.count) services! :\(services)”)
}

Start discovering characteristics.

objc

[peripheral discoverCharacteristics:nil forService:service];

swift

peripheral.discoverCharacteristics(nil, forService: service)

Receive the result of discovering characteristics.

objc

- (void)                      peripheral:(CBPeripheral *)peripheral
    didDiscoverCharacteristicsForService:(CBService *)service
                                   error:(NSError *)error
{
    if (error) {
        NSLog(@”error: %@”, error);
        return;
    }

    NSArray *characteristics = service.characteristics;
    NSLog(@”Found %lu characteristics!”, (unsigned long)characteristics.count);
}

swift

func peripheral(peripheral: CBPeripheral,
    didDiscoverCharacteristicsForService service: CBService,
    error: NSError?)
{
    if let error = error {
        print(“error: \(error)”)
        return
    }

    let characteristics = service.characteristics
    print(“Found \(characteristics.count) characteristics!)
}

Read

Start reading the value of a characteristic.

objc

[peripheral readValueForCharacteristic:characteristic];

swift

peripheral.readValueForCharacteristic(characteristic)

Receive the result of reading.

objc

- (void)                 peripheral:(CBPeripheral *)peripheral
    didUpdateValueForCharacteristic:(CBCharacteristic *)characteristic
                              error:(NSError *)error
{
    if (error) {
        NSLog(@”Failed… error: %@”, error);
        return;
    }

    NSLog(@"characteristic uuid:%@, value%@”,
      characteristic.UUID, characteristic.value);
}

swift

func peripheral(peripheral: CBPeripheral,
    didUpdateValueForCharacteristic characteristic: CBCharacteristic,
    error: NSError?)
{
    if let error = error {
        print(“Failed… error: \(error)”)
        return
    }

    print(“characteristic uuid: \(characteristic.UUID), value: \(characteristic.value)”)
}

Write

Start writing the value of a characteristic.

objc

[peripheral writeValue:data
     forCharacteristic:characteristic
                  type:CBCharacteristicWriteWithResponse];

swift

peripheral.writeValue(data, forCharacteristic: characteristic, type: CBCharacteristicWriteType.WithResponse)

Receive the result of writing.

objc

- (void)                peripheral:(CBPeripheral *)peripheral
    didWriteValueForCharacteristic:(CBCharacteristic *)characteristic
                             error:(NSError *)error
{
    if (error) {
        NSLog(@"error:%@”, error);
        return;
    }

    NSLog(@”Succeeded!”);
}

swift

func peripheral(peripheral: CBPeripheral,
    didWriteValueForCharacteristic characteristic: CBCharacteristic,
    error: NSError?)
{
    if let error = error {
        print(“error: \(error)”)
        return
    }

    print(“Succeeded!”)
}

Notify

Start receiving notifications for changes of a characteristic’s value.

objc

[peripheral setNotifyValue:YES
         forCharacteristic:characteristic];

swift

peripheral.setNotifyValue(true, forCharacteristic: characteristic)

Stop receiving notifications for changes of a characteristic’s value.

objc

[peripheral setNotifyValue:NO
         forCharacteristic:characteristic];

swift

peripheral.setNotifyValue(false, forCharacteristic: characteristic)

Receive the result of starting/stopping to receive notification.

objc

- (void)                             peripheral:(CBPeripheral *)peripheral
    didUpdateNotificationStateForCharacteristic:(CBCharacteristic *)characteristic
                                          error:(NSError *)error
{
    if (error) {
        NSLog(@"error:%@”, error);
    }
    else {
        NSLog(@"isNotifying:%d”, characteristic.isNotifying);
    }
}

swift

func peripheral(peripheral: CBPeripheral,
    didUpdateNotificationStateForCharacteristic characteristic: CBCharacteristic,
    error: NSError?)
{
    if let error = error { 
        print(“error: \(error)”)
    }
    else {
        print(“isNotifying: \(characteristic.isNotifying)”)
    }
}

Receive notifications for changes of a characteristic’s value.

objc

- (void) peripheral:(CBPeripheral *)peripheral
 didUpdateValueForCharacteristic:(CBCharacteristic *)characteristic
 error:(NSError *)error
{
    if (error) {
        NSLog(@"error:%@”, error);
        return;
    }

    NSLog(@"characteristic UUID:%@, value:%@",
          characteristic.UUID, characteristic.value);
}

swift

func peripheral(peripheral: CBPeripheral,
 didUpdateValueForCharacteristic characteristic: CBCharacteristic,
 error: NSError?)
{
    if let error = error {
        print(“error: \(error)”)
        return
    }

    print(“characteristic UUID: \(characteristic.UUID), value: \(characteristic.value)”)
}

Peripheral Manager

Initialize

Adopt protocol and define properties.

objc

@interface SomeClass () <CBPeripheralManagerDelegate>
@property (nonatomic, strong) CBPeripheralManager *peripheralManager;
@end

swift

class SomeClass: SomeSuperclass, CBPeripheralManagerDelegate {
 var peripheralManager: CBPeripheralManager!

Initialize CBPeripheralManager.

objc

self.peripheralManager = [[CBPeripheralManager alloc] initWithDelegate:self queue:nil];

swift

peripheralManager = CBPeripheralManager(delegate: self, queue: nil)

Advertise

Receive the update of peripheral manager’s state. **Required**

objc

- (void)peripheralManagerDidUpdateState:(CBPeripheralManager *)peripheral
{
    NSLog(@”state:%ld”, (long)peripheral.state);
}

swift

func peripheralManagerDidUpdateState(peripheral: CBPeripheralManager)
{
    print(“state: \(peripheral.state)”)
}

Start advertising.

objc

NSDictionary *advertisementData = @{CBAdvertisementDataLocalNameKey: @”Test Device”};
[self.peripheralManager startAdvertising:advertisementData];

swift

let advertisementData = [CBAdvertisementDataLocalNameKey: “Test Device”]
peripheralManager.startAdvertising(advertisementData)

Receive the result of starting to advertise.

objc

- (void)peripheralManagerDidStartAdvertising:(CBPeripheralManager *)peripheral
                                       error:(NSError *)error
{
    if (error) {
        NSLog(@”Failed… error:%@”, error);
        return;
    }

    NSLog(@”Succeeded!”);
}

swift

func peripheralManagerDidStartAdvertising(peripheral: CBPeripheralManager, error: NSError?)
{ 
    if let error = error {
        print(“Failed… error: \(error)”)
        return
    }

    print(“Succeeded!”)
}

Stop advertising.

objc

[self.peripheralManager stopAdvertising];

swift

peripheralManager.stopAdvertising()

Add services

Create a service.

objc

CBUUID *serviceUUID = [CBUUID UUIDWithString:kServiceUUID];
CBMutableService *service;
service = [[CBMutableService alloc] initWithType:serviceUUID
                                         primary:YES];

swift

let serviceUUID = CBUUID(string: kServiceUUID)
let service = CBMutableService(type: serviceUUID, primary: true)

Create characteristics.

objc

CBUUID *characteristicUUID = [CBUUID UUIDWithString:kCharacteristicUUID];

CBCharacteristicProperties properties = (
    CBCharacteristicPropertyNotify |
    CBCharacteristicPropertyRead |
    CBCharacteristicPropertyWrite
);

CBAttributePermissions permissions = (CBAttributePermissionsReadable | CBAttributePermissionsWriteable);

CBMutableCharacteristic *c;
c = [[CBMutableCharacteristic alloc] initWithType:characteristicUUID
                                       properties:properties
                                            value:nil
                                      permissions:permissions];

swift

let characteristicUUID = CBUUID(string: kCharacteristicUUID)
let properties: CBCharacteristicProperties = [.Notify, .Read, .Write]
let permissions: CBAttributePermissions = [.Readable, .Writeable]
let characteristic = CBMutableCharacteristic(
    type: characteristicUUID,
    properties: properties,
    value: nil,
    permissions: permissions)

Add characteristics to a service.

objc

service.characteristics = @[characteristic1, characteristic2];

swift

service.characteristics = [characteristic1, characteristic2]

Add a service to the peripheral manager.

objc

[self.peripheralManager addService:service];

swift

peripheralManager.addService(service)

Receive the result of adding a service.

objc

- (void)peripheralManager:(CBPeripheralManager *)peripheral
            didAddService:(CBService *)service
                    error:(NSError *)error
{
    if (error) {
        NSLog(@"error:%@”, error);
        return;
    }

    NSLog(@"service:%@”, service);
}

swift

func peripheralManager(peripheral: CBPeripheralManager, didAddService service: CBService, error: NSError?)
{
    if let error = error {
        print(“error: \(error)”)
        return
    }

    print(“service: \(service)”)
}

Respond to Read requests

objc

- (void)peripheralManager:(CBPeripheralManager *)peripheral
    didReceiveReadRequest:(CBATTRequest *)request
{
    if ([request.characteristic.UUID isEqual:self.characteristic.UUID])
    {
        // Set the characteristic's value to the request
        request.value = self.characteristic.value;
 
        // Respond to the request
        [self.peripheralManager respondToRequest:request 
                                      withResult:CBATTErrorSuccess];
    }
}

swift

func peripheralManager(peripheral: CBPeripheralManager, didReceiveReadRequest request: CBATTRequest)
{
    if request.characteristic.UUID.isEqual(characteristic.UUID)
    { 
        // Set the correspondent characteristic's value
        // to the request
        request.value = characteristic.value
 
        // Respond to the request
        peripheralManager.respondToRequest(
            request,
            withResult: .Success)
    }
}

Respond to Write requests

objc

- (void)  peripheralManager:(CBPeripheralManager *)peripheral
    didReceiveWriteRequests:(NSArray *)requests
{
    for (CBATTRequest *aRequest in requests)
    {
        if ([aRequest.characteristic.UUID isEqual:self.characteristic.UUID])
        {
            // Set the request's value
            // to the correspondent characteristic 
            self.characteristic.value = aRequest.value;
        }
    }

    [self.peripheralManager respondToRequest:requests[0]
                                  withResult:CBATTErrorSuccess];
}

swift

func peripheralManager(peripheral: CBPeripheralManager, didReceiveWriteRequests requests: [CBATTRequest])
{
    for request in requests
    {
        if request.characteristic.UUID.isEqual(characteristic.UUID) 
        {
            // Set the request's value
            // to the correspondent characteristic
            characteristic.value = request.value
        }
    }

    peripheralManager.respondToRequest(requests[0], withResult: .Success)
}

Respond to Notifications/Indications

Receive subscribe requests.

objc

- (void)       peripheralManager:(CBPeripheralManager *)peripheral
                         central:(CBCentral *)central
    didSubscribeToCharacteristic:(CBCharacteristic *)characteristic
{
    NSLog(@"subscribed centrals: %@”, self.characteristic.subscribedCentrals);
}

swift

func peripheralManager(
    peripheral: CBPeripheralManager,
    central: CBCentral,
    didSubscribeToCharacteristic characteristic: CBCharacteristic)
{
    print(“subscribed centrals: \( characteristic.subscribedCentrals)”)
}

Receive unsubscribe requests.

objc

- (void)         peripheralManager:(CBPeripheralManager *)peripheral
                           central:(CBCentral *)central
  didUnsubscribeFromCharacteristic:(CBCharacteristic *)characteristic
{
    NSLog(@"subscribed centrals: %@”, 
          self.characteristic.subscribedCentrals);
}

swift

func peripheralManager(
    peripheral: CBPeripheralManager,
    central: CBCentral,
    didUnsubscribeFromCharacteristic characteristic: CBCharacteristic)
{
    print(“subscribed centrals: \(characteristic.subscribedCentrals)”)
}

Notify/Indicate updating a value

objc

self.characteristic.value = data;

[self.peripheralManager updateValue:data
                  forCharacteristic:self.characteristic
               onSubscribedCentrals:nil];

swift

characteristic.value = data

peripheralManager.updateValue(
    data,
    forCharacteristic: characteristic,
    onSubscribedCentrals: nil)

About me

iOS Freelancer in Tokyo, Japan / Berlin, Germany. Works from abroad are welcome.

My Profile Summary (Including contact information)

WORKS

Developed over 40 apps from scratch including many IoT / Wearable related apps using Bluetooth Low Energy.

Books

The Author of 2 books

• iOS x BLE Core Bluetooth Programming”​ (2015)

• “iOS Programming — Advanced 100 Recipes” (2013)

Open Sources

The owner of famous open source repositories

• iOS-10-Sampler #1 on GitHub trending, over 3000 stars (2016)
• iOS-9-Sampler #1 on GitHub trending, over 3000 stars (2015)
• #1 on GitHub trending, over 3000 stars (2015)
• iOS-8-Sampler #1 on GitHub trending, over 3000 stars (2014)
• iOS-7-Sampler #1 on GitHub trending, over 3000 stars (2013)
• AnimatedTransitionGallery #1 on GitHub trending, over 1500 stars (2014)
• PulsingHalo over 1000 stars (2013)
• watchOS-2-Sampler nearly 1000 stars (2015)

and so on.

TOTAL 20,000 stars / #7 on GitHub Awards WORLDWIDE rank in ObjC

Presentations

• AltConf 2016 (San Francisco)
• UIConf 2016 (Berlin)
• iOSCon 2016 (London)

Contacts

• LinkedIn
• GitHub
• Email
• Twitter
• Facebook