Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/anatoliyv/assistantkit
Easy way to detect iOS device properties, OS versions and work with screen sizes. Powered by Swift.
https://github.com/anatoliyv/assistantkit
battery device ios ios-device ios-framework ipad iphone swift swift-4 swift-framework
Last synced: about 3 hours ago
JSON representation
Easy way to detect iOS device properties, OS versions and work with screen sizes. Powered by Swift.
- Host: GitHub
- URL: https://github.com/anatoliyv/assistantkit
- Owner: anatoliyv
- License: mit
- Created: 2016-06-08T11:37:30.000Z (over 8 years ago)
- Default Branch: master
- Last Pushed: 2020-12-08T08:42:30.000Z (almost 4 years ago)
- Last Synced: 2024-09-24T20:37:50.353Z (about 8 hours ago)
- Topics: battery, device, ios, ios-device, ios-framework, ipad, iphone, swift, swift-4, swift-framework
- Language: Swift
- Homepage:
- Size: 176 KB
- Stars: 586
- Watchers: 18
- Forks: 52
- Open Issues: 5
-
Metadata Files:
- Readme: README.md
- Changelog: CHANGELOG.md
- License: LICENSE
Awesome Lists containing this project
README
[](https://travis-ci.org/anatoliyv/AssistantKit)
[](http://cocoapods.org/pods/AssistantKit)
[](http://cocoapods.org/pods/AssistantKit)
[](http://cocoapods.org/pods/AssistantKit)
Easy way to detect device environment:
- [x] [Device model and version](https://github.com/anatoliyv/AssistantKit#device-version-information)
- [x] [Screen resolution](https://github.com/anatoliyv/AssistantKit#device-screen-parameters)
- [x] [Interface orientation](https://github.com/anatoliyv/AssistantKit#interface-orientation)
- [x] [iOS version](https://github.com/anatoliyv/AssistantKit#detecting-and-comparing-ios-version)
- [x] [Battery state](https://github.com/anatoliyv/AssistantKit#battery)
- [x] [Environment](https://github.com/anatoliyv/AssistantKit#environment)
Helps to:
- [x] [work with bundle Document and Cache folders](https://github.com/anatoliyv/AssistantKit/blob/master/README.md#working-with-directories)
- [x] [easily assign sizes for different devices](https://github.com/anatoliyv/AssistantKit#detecting-screen-family)
## Installation
AssistantKit is available through [CocoaPods](http://cocoapods.org). To install
it, simply add the following line to your Podfile:
```ruby
pod "AssistantKit"
```
## Usage
### Device version information
To get the current device type, use:
```swift
let device = Device.type
switch device {
case .phone: print("iPhone")
case .pad: print("iPad")
case .pod: print("iPod")
case .simulator: print("Simulator")
default: print("Unknown")
}
```
You can check the exact device version with next code. All possible values of `version` can be
found in the `Version` enum, located in the `Version.swift` file.
```swift
switch Device.version {
case .phone5C: print("iPhone 5C")
case .phone6: print("iPhone 6")
case .phone6S: print("iPhone 6S")
case .phone6Plus: print("iPhone 6 Plus")
case .phone6SPlus: print("iPhone 6 S Plus")
// and more iPhones
case .padAir: print("iPad Air")
case .padAir2: print("iPad Air 2")
case .padMini: print("iPad Mini")
case .padPro: print("iPad Pro")
// and more iPads
case .podTouch6: print("iPod 6")
// and more iPods
case .simulator: print("Simulator")
default: print("Unknown device")
}
```
There are few properties that detect device type
```swift
Device.isPhone // true for iPhones even if it's Simulator
Device.isPad // true for iPads even if it's Simulator
Device.isPadPro // true for iPad Pros even if it's Simulator
Device.isPod // true for iPods
Device.isSimulator // true for Simulators
Device.isNotched // true for newer device version with notch
```
To get raw device code use
```
Device.versionCode
```
### Device screen parameters
Detecting screen size can be detected with next code. All possible values could be
found in the `Screen` enum, located in `Screen.swift`.
```swift
switch Device.screen {
case .inches_4_7: print("4.7 inches")
case .inches_5_5: print("5.5 inches")
case .inches_7_9: print("7.9 inches")
case .inches_9_7: print("9.7 inches")
case .inches_12_9: print("12.9 inches")
default: print("Other display")
}
```
### Compare screens
`Screen` is cinfirming to `Comparable` protocol:
```
Screen.inches_3_5 < Screen.inches_4_0 // Will be `true`
```
### Detecting screen family
Often it is required to assign different parameters based on specific screen resolution.
There are 3 methods that will help you to detect what parameters to use. But
first of all let me introduce `ScreenFamily`.
This is enum that breaks all possible screens into 3 groups:
- `.old`: Reproduce old iPhones with 3.5 and 4.0 inches screens
- `.small`: Other iPhones/iPods without iPhone 6 Plus
- `.medium`: iPhone 6 Plus and iPad Mini
- `.big`: iPad and iPad Pro
You can detect screen family by:
```swift
let family = Device.screen.family
```
And now back to methods:
#### Value by device type
To assign different values for iPhone and iPad devices you can use:
```swift
// Method definition
static public func size(phone phone: T, pad: T) -> T
// Usage example
let size = Device.size(phone: 13, pad: 15)
let font = UIFont(name: "Arial", size: CGFloat(size))
```
On iPhones your font size will be 13.0, on iPads 15.0
#### Value by ScreenFamily
Another method based on `ScreenFamily`:
```swift
// Method definition
static public func size(small small: T, medium: T, big: T) -> T
// Usage example
let otherSize = Device.size(small: 12, medium: 14, big: 15)
let otherFont = UIFont(name: "Arial", size: CGFloat(otherSize))
```
In this case for small screens your font will be 12.0, for medium 14.0 and for big 15.0 inches.
*Important notice:* By default if screen family can not be detected `size` method will
assign small value.
#### Value by exact screen size
Also you can return value for specific screen size. There is another size method you can use.
Incoming parameter should be a screen size. If it is not defined nearest value will be used. Code example:
```swift
// Method definition
static public func size(sizes sizes: [Screen : T]) -> T?
// Usage example
let sizes: [Screen: AnyObject] = [
.inches_3_5: 12,
.inches_4_0: 13,
.inches_4_7: 14,
.inches_9_7: 15
]
let exactSize = Device.size(sizes: sizes) as! Int
let _ = UIFont(name: "Arial", size: CGFloat(exactSize))
```
*Important notice:* This method can return `nil` if you pass an empty array as a parameter. Be careful with implicit unwrapping.
After that your font will be:
- 12 for 3.5" inches (older devices)
- 13 for iPhone 5, 5S
- 14 for iPhone 6, 6Plus and iPad mini
- and 15 for other iPads
### Screen scale
```swift
switch Device.scale {
case .x1: print("Not retina")
case .x2: print("Retina 2X")
case .x3: print("Retina 3X")
default: print("Unknown scale")
}
```
Also there is a property to detect if it's retina display:
```swift
Device.isRetina // true if device screen scale > 1.0
```
### Interface orientation
There are two properties that will help you to know current orientation:
```swift
Device.isLandscape // true if landscape
Device.isPortrait // true if portrait
```
### Slide Over / Multitasking layout for iPad
To detect slide over layout on iPads just call:
```swift
Device.isSlideOverLayout // true if iPad is in multitasking / slide over layout
```
## Detecting and comparing iOS version
You can detect iOS version in runtime. There are next different methods that will help you to
do it:
```swift
Device.osVersion // Current version as a `OSVersion` model
Device.osVersion == Device.os12 // true if iOS 12.0
Device.osVersion >= Device.os9 // true if iOS >= 9.0
Device.osVersion < Device.os11 // true if iOS < 11.0
etc.
```
There are next constants representating Main iOS versions:
```swift
Device.os8
Device.os9
Device.os10
Device.os11
Device.os12
```
### Working with directories
There are few helper methods to make access to Documents and Caches directoies easier.
Take a look at code examples:
```swift
Bundle.documentsDirectoryURL // URL to .DocumentDirectory
Bundle.documentsDirectoryPath // Path to .DocumentDirectory
Bundle.cachesDirectoryURL // URL to .CachesDirectory
Bundle.cachesDirectoryPath // Path to .CachesDirectory
let filePath = "directory/filename.txt"
Bundle.filePathInDocumentsDirectory(toFile: filePath) // Path to file in .DocumentDirectory
Bundle.filePathInCachesDirectory(toFile: filePath) // Path to file in .CachesDirectory
```
## Environment
Used to detect environment options. Right now there is only one property:
```
/// Return `true` if running unit tests
Environment.isRunningUnitTests
```
## Battery
There is a way to get battery state and level with these methods. It will enable monitoring if it's not enabled yet.
```
Device.Battery.state // Represent `UIDeviceBatteryState`
Device.Battery.level // in range 0...1 -1 for simulators
```
## TODO
- [ ] Add tvOS support
Write me or make a pull request if you have any ideas what else functionality can be useful in this repo.
## Author
- [email protected]
- [@anatoliy_v](https://twitter.com/anatoliy_v)
- [LinkedIn](https://www.linkedin.com/in/anatoliyvoropay)
## More Device-detecting libs
- [Ehkoo's Device](https://github.com/Ekhoo/Device)
- [Schickling's Device.swift](https://github.com/schickling/Device.swift)
- [DeviceKit](https://github.com/dennisweissmann/DeviceKit)
## License
AssistantKit is available under the MIT license. See the LICENSE file for more info.