Andrea Busi
711 lines
32 KiB
Swift
711 lines
32 KiB
Swift
//
|
|
// SeismicNetworkTableViewCell.swift
|
|
// Earthquake Network
|
|
//
|
|
// Created by Busi Andrea on 22/09/2020.
|
|
// Copyright © 2020 Earthquake Network. All rights reserved.
|
|
//
|
|
|
|
import UIKit
|
|
import MapKit
|
|
import CoreLocation
|
|
|
|
protocol SeismicNetworkTableViewCellDelegate: class {
|
|
func seismicNetworkCellDidTapShare(_ cell: SeismicNetworkTableViewCell)
|
|
func seismicNetworkCellDidTapMap(_ cell: SeismicNetworkTableViewCell)
|
|
func seismicNetworkCellDidTapWeather(_ cell: SeismicNetworkTableViewCell)
|
|
func seismicNetworkCellDidTapCalendar(_ cell: SeismicNetworkTableViewCell)
|
|
func seismicNetworkCellDidTapSettings(_ cell: SeismicNetworkTableViewCell)
|
|
func seismicNetworkCellDidTapClose(_ cell: SeismicNetworkTableViewCell)
|
|
}
|
|
|
|
class SeismicNetworkTableViewCell: UITableViewCell {
|
|
|
|
static let Identifier = "SeismicNetworkTableViewCell"
|
|
|
|
typealias MagnitudeColors = (textColor: UIColor, startColor: UIColor, endColor: UIColor)
|
|
|
|
/// Available informations to display inside the cell
|
|
enum InformationType: Int {
|
|
case preliminary
|
|
case time
|
|
case distance
|
|
case coordinate
|
|
case population
|
|
case realtimeSmartphones
|
|
case reportUsers
|
|
}
|
|
|
|
/// Available cell type
|
|
enum DisplayType {
|
|
/// Compact view
|
|
case normal
|
|
/// Cell with map visible
|
|
case mapExpanded
|
|
/// Cell with weather info visible
|
|
case weatherExpanded
|
|
}
|
|
|
|
/// Delegate
|
|
weak var delegate: SeismicNetworkTableViewCellDelegate?
|
|
|
|
// MARK: - Internal
|
|
|
|
private static let DefaultVerticalSpacing: CGFloat = 6.0
|
|
private static let DefaultBodyFont = UIFont.preferredFont(forTextStyle: .body)
|
|
private static let DefaultBodyFontLight = UIFont.preferredFont(for: .body, weight: .light)
|
|
|
|
private static var dateFormatter: DateFormatter = {
|
|
let formatter = DateFormatter()
|
|
formatter.dateFormat = "HH:mm:ss d-MMM"
|
|
return formatter
|
|
}()
|
|
|
|
/// Seismic to show
|
|
private var seismic: EQNSisma?
|
|
private(set) var displayType = DisplayType.normal
|
|
private var informationTypes = [InformationType]()
|
|
|
|
private var colors: MagnitudeColors?
|
|
|
|
// MARK: - UI Components
|
|
|
|
private lazy var containerView: UIView = {
|
|
let view = UIView(frame: .zero)
|
|
view.translatesAutoresizingMaskIntoConstraints = false
|
|
view.layer.cornerRadius = AppTheme.shared.borderCornerRadius
|
|
view.layer.masksToBounds = true
|
|
return view
|
|
}()
|
|
|
|
private lazy var titleImageView: UIImageView = {
|
|
let imageView = UIImageView(frame: .zero)
|
|
imageView.translatesAutoresizingMaskIntoConstraints = false
|
|
return imageView
|
|
}()
|
|
|
|
private lazy var placeLabel: UILabel = {
|
|
let label = UILabel()
|
|
label.translatesAutoresizingMaskIntoConstraints = false
|
|
label.font = UIFont.preferredFont(for: .title2, weight: .semibold)
|
|
label.numberOfLines = 2
|
|
return label
|
|
}()
|
|
|
|
private lazy var networkLabel: UILabel = {
|
|
let label = UILabel()
|
|
label.translatesAutoresizingMaskIntoConstraints = false
|
|
label.backgroundColor = UIColor.white.withAlphaComponent(0.5)
|
|
label.textAlignment = .center
|
|
return label
|
|
}()
|
|
|
|
private lazy var magnitudeLabel: UILabel = {
|
|
let label = UILabel()
|
|
label.translatesAutoresizingMaskIntoConstraints = false
|
|
label.font = UIFont.preferredFont(forTextStyle: .largeTitle)
|
|
label.textColor = .red
|
|
return label
|
|
}()
|
|
|
|
private lazy var depthLabel: UILabel = {
|
|
let label = UILabel()
|
|
label.translatesAutoresizingMaskIntoConstraints = false
|
|
label.font = Self.DefaultBodyFontLight
|
|
return label
|
|
}()
|
|
|
|
private lazy var timeLabel: UILabel = {
|
|
let label = UILabel()
|
|
label.translatesAutoresizingMaskIntoConstraints = false
|
|
label.font = Self.DefaultBodyFontLight
|
|
return label
|
|
}()
|
|
|
|
private lazy var distanceLabel: UILabel = {
|
|
let label = UILabel()
|
|
label.translatesAutoresizingMaskIntoConstraints = false
|
|
label.font = Self.DefaultBodyFontLight
|
|
return label
|
|
}()
|
|
|
|
private lazy var coordinateLabel: UILabel = {
|
|
let label = UILabel()
|
|
label.translatesAutoresizingMaskIntoConstraints = false
|
|
label.font = Self.DefaultBodyFontLight
|
|
return label
|
|
}()
|
|
|
|
private lazy var populationLabel: UILabel = {
|
|
let label = UILabel()
|
|
label.translatesAutoresizingMaskIntoConstraints = false
|
|
label.font = Self.DefaultBodyFontLight
|
|
return label
|
|
}()
|
|
|
|
private lazy var smartphonesLabel: UILabel = {
|
|
let label = UILabel()
|
|
label.translatesAutoresizingMaskIntoConstraints = false
|
|
label.numberOfLines = 0
|
|
label.font = Self.DefaultBodyFont
|
|
label.textAlignment = .center
|
|
return label
|
|
}()
|
|
|
|
private lazy var alertsLabel: UILabel = {
|
|
let label = UILabel()
|
|
label.translatesAutoresizingMaskIntoConstraints = false
|
|
label.numberOfLines = 0
|
|
label.font = Self.DefaultBodyFont
|
|
label.textAlignment = .center
|
|
return label
|
|
}()
|
|
|
|
private lazy var mapView: MKMapView = {
|
|
let mapView = MKMapView(frame: .zero)
|
|
mapView.translatesAutoresizingMaskIntoConstraints = false
|
|
mapView.isScrollEnabled = false
|
|
mapView.isZoomEnabled = false
|
|
mapView.layer.cornerRadius = AppTheme.shared.borderCornerRadius
|
|
mapView.layer.masksToBounds = true
|
|
return mapView
|
|
}()
|
|
|
|
private lazy var weatherImageView: UIImageView = {
|
|
let imageView = UIImageView(frame: .zero)
|
|
imageView.translatesAutoresizingMaskIntoConstraints = false
|
|
return imageView
|
|
}()
|
|
|
|
private lazy var weatherInfoLabel: UILabel = {
|
|
let label = UILabel()
|
|
label.translatesAutoresizingMaskIntoConstraints = false
|
|
label.numberOfLines = 0
|
|
label.font = Self.DefaultBodyFontLight
|
|
return label
|
|
}()
|
|
|
|
// MARK: - Init
|
|
|
|
override init(style: UITableViewCell.CellStyle, reuseIdentifier: String?) {
|
|
super.init(style: style, reuseIdentifier: reuseIdentifier)
|
|
setupUI()
|
|
}
|
|
|
|
required init?(coder: NSCoder) {
|
|
super.init(coder: coder)
|
|
setupUI()
|
|
}
|
|
|
|
// MARK: - Setup
|
|
|
|
private func setupUI() {
|
|
selectionStyle = .default
|
|
translatesAutoresizingMaskIntoConstraints = false
|
|
backgroundColor = .clear
|
|
|
|
// container view
|
|
contentView.addSubview(containerView)
|
|
containerView.topAnchor.constraint(equalTo: contentView.topAnchor, constant: 5.0).isActive = true
|
|
containerView.trailingAnchor.constraint(equalTo: contentView.trailingAnchor, constant: -10.0).isActive = true
|
|
containerView.leadingAnchor.constraint(equalTo: contentView.leadingAnchor, constant: 10.0).isActive = true
|
|
containerView.bottomAnchor.constraint(equalTo: contentView.bottomAnchor, constant: -5.0).isActive = true
|
|
|
|
// this variable is used to keep track of the previous view, in order to attach proper constraints
|
|
var previousView: UIView = containerView
|
|
|
|
// preliminary banner on top of the cell
|
|
if informationTypes.contains(.preliminary) {
|
|
let preliminaryLabel = UILabel()
|
|
preliminaryLabel.translatesAutoresizingMaskIntoConstraints = false
|
|
preliminaryLabel.text = NSLocalizedString("official_prelimiary", comment: "").uppercased()
|
|
preliminaryLabel.textAlignment = .center
|
|
preliminaryLabel.backgroundColor = .red
|
|
preliminaryLabel.textColor = .yellow
|
|
|
|
containerView.addSubview(preliminaryLabel)
|
|
preliminaryLabel.heightAnchor.constraint(equalToConstant: 30.0).isActive = true
|
|
preliminaryLabel.leadingAnchor.constraint(equalTo: containerView.leadingAnchor).isActive = true
|
|
preliminaryLabel.trailingAnchor.constraint(equalTo: containerView.trailingAnchor).isActive = true
|
|
preliminaryLabel.topAnchor.constraint(equalTo: containerView.topAnchor).isActive = true
|
|
|
|
previousView = preliminaryLabel
|
|
}
|
|
|
|
// title (bell icon, place label, seismic network and share button)
|
|
let titleComponentsHeight: CGFloat = 30.0
|
|
let stackViewTitle = UIStackView()
|
|
stackViewTitle.translatesAutoresizingMaskIntoConstraints = false
|
|
stackViewTitle.axis = .horizontal
|
|
stackViewTitle.distribution = .fill
|
|
stackViewTitle.alignment = .center
|
|
stackViewTitle.spacing = 4
|
|
|
|
let shareButton = UIButton(type: .custom)
|
|
shareButton.setImage(UIImage(named: "share_icon"), for: .normal)
|
|
shareButton.addTarget(self, action: #selector(shareTapped(_:)), for: .touchUpInside)
|
|
|
|
stackViewTitle.addArrangedSubview(titleImageView)
|
|
stackViewTitle.addArrangedSubview(placeLabel)
|
|
stackViewTitle.addArrangedSubview(networkLabel)
|
|
stackViewTitle.addArrangedSubview(shareButton)
|
|
|
|
titleImageView.heightAnchor.constraint(equalToConstant: titleComponentsHeight).isActive = true
|
|
titleImageView.widthAnchor.constraint(equalTo: titleImageView.heightAnchor).isActive = true
|
|
networkLabel.heightAnchor.constraint(equalToConstant: 40.0).isActive = true
|
|
networkLabel.widthAnchor.constraint(equalToConstant: 60.0).isActive = true
|
|
shareButton.widthAnchor.constraint(equalToConstant: titleComponentsHeight).isActive = true
|
|
shareButton.widthAnchor.constraint(equalTo: shareButton.heightAnchor).isActive = true
|
|
|
|
let titleTopAnchor = previousView == containerView ? containerView.layoutMarginsGuide.topAnchor : previousView.bottomAnchor
|
|
containerView.addSubview(stackViewTitle)
|
|
stackViewTitle.topAnchor.constraint(equalTo: titleTopAnchor).isActive = true
|
|
stackViewTitle.trailingAnchor.constraint(equalTo: containerView.layoutMarginsGuide.trailingAnchor).isActive = true
|
|
stackViewTitle.leadingAnchor.constraint(equalTo: containerView.layoutMarginsGuide.leadingAnchor).isActive = true
|
|
|
|
let separator1 = addSeparator(constraintTo: stackViewTitle.bottomAnchor)
|
|
let informationsLeadingAnchor = separator1.leadingAnchor
|
|
let informationsTrailingAnchor = separator1.trailingAnchor
|
|
|
|
// magnitude information
|
|
containerView.addSubview(magnitudeLabel)
|
|
magnitudeLabel.topAnchor.constraint(equalTo: separator1.bottomAnchor, constant: Self.DefaultVerticalSpacing).isActive = true
|
|
magnitudeLabel.leadingAnchor.constraint(equalTo: informationsLeadingAnchor, constant: 14).isActive = true
|
|
|
|
if !informationTypes.contains(.preliminary) {
|
|
containerView.addSubview(depthLabel)
|
|
depthLabel.lastBaselineAnchor.constraint(equalTo: magnitudeLabel.lastBaselineAnchor).isActive = true
|
|
depthLabel.leadingAnchor.constraint(equalTo: magnitudeLabel.trailingAnchor, constant: 16).isActive = true
|
|
}
|
|
|
|
// informations
|
|
let stackViewInformations = UIStackView()
|
|
stackViewInformations.translatesAutoresizingMaskIntoConstraints = false
|
|
stackViewInformations.axis = .vertical
|
|
stackViewInformations.distribution = .equalSpacing
|
|
stackViewInformations.spacing = 4
|
|
|
|
if informationTypes.contains(.time) {
|
|
stackViewInformations.addArrangedSubview(timeLabel)
|
|
}
|
|
if informationTypes.contains(.distance) {
|
|
stackViewInformations.addArrangedSubview(distanceLabel)
|
|
}
|
|
if informationTypes.contains(.coordinate) {
|
|
stackViewInformations.addArrangedSubview(coordinateLabel)
|
|
}
|
|
if informationTypes.contains(.population) {
|
|
stackViewInformations.addArrangedSubview(populationLabel)
|
|
}
|
|
|
|
containerView.addSubview(stackViewInformations)
|
|
stackViewInformations.topAnchor.constraint(equalTo: magnitudeLabel.bottomAnchor, constant: Self.DefaultVerticalSpacing).isActive = true
|
|
stackViewInformations.leadingAnchor.constraint(equalTo: informationsLeadingAnchor, constant: 14).isActive = true
|
|
stackViewInformations.trailingAnchor.constraint(equalTo: informationsTrailingAnchor, constant: -14).isActive = true
|
|
|
|
previousView = stackViewInformations
|
|
if informationTypes.contains(.realtimeSmartphones) || informationTypes.contains(.reportUsers) {
|
|
let separator2 = addSeparator(constraintTo: stackViewInformations.bottomAnchor)
|
|
|
|
let stackViewReports = UIStackView()
|
|
stackViewReports.translatesAutoresizingMaskIntoConstraints = false
|
|
stackViewReports.axis = .vertical
|
|
stackViewReports.distribution = .equalSpacing
|
|
stackViewReports.alignment = .center
|
|
stackViewReports.spacing = Self.DefaultVerticalSpacing
|
|
|
|
if informationTypes.contains(.realtimeSmartphones) {
|
|
stackViewReports.addArrangedSubview(smartphonesLabel)
|
|
}
|
|
if informationTypes.contains(.reportUsers) {
|
|
stackViewReports.addArrangedSubview(alertsLabel)
|
|
}
|
|
|
|
containerView.addSubview(stackViewReports)
|
|
stackViewReports.topAnchor.constraint(equalTo: separator2.bottomAnchor, constant: Self.DefaultVerticalSpacing).isActive = true
|
|
stackViewReports.leadingAnchor.constraint(equalTo: containerView.layoutMarginsGuide.leadingAnchor, constant: 20.0).isActive = true
|
|
stackViewReports.trailingAnchor.constraint(equalTo: containerView.layoutMarginsGuide.trailingAnchor, constant: -20.0).isActive = true
|
|
|
|
let separator3 = addSeparator(constraintTo: stackViewReports.bottomAnchor)
|
|
previousView = separator3
|
|
}
|
|
|
|
// buttons
|
|
let stackViewButtons = UIStackView()
|
|
stackViewButtons.translatesAutoresizingMaskIntoConstraints = false
|
|
stackViewButtons.axis = .horizontal
|
|
stackViewButtons.distribution = .fillEqually
|
|
stackViewButtons.spacing = 4
|
|
|
|
let buttonMap = createRoundedButton(title: "🗺", action: #selector(mapTapped(_:)))
|
|
stackViewButtons.addArrangedSubview(buttonMap)
|
|
let buttonWeather = createRoundedButton(title: "🌤", action: #selector(weatherTapped(_:)))
|
|
stackViewButtons.addArrangedSubview(buttonWeather)
|
|
let buttonCalendar = createRoundedButton(title: "📆", action: #selector(calendarTapped(_:)))
|
|
stackViewButtons.addArrangedSubview(buttonCalendar)
|
|
let buttonSettings = createRoundedButton(title: "🔧", action: #selector(settingsTapped(_:)))
|
|
stackViewButtons.addArrangedSubview(buttonSettings)
|
|
|
|
containerView.addSubview(stackViewButtons)
|
|
stackViewButtons.heightAnchor.constraint(equalToConstant: 30.0).isActive = true
|
|
stackViewButtons.topAnchor.constraint(equalTo: previousView.bottomAnchor, constant: Self.DefaultVerticalSpacing).isActive = true
|
|
stackViewButtons.leadingAnchor.constraint(equalTo: containerView.layoutMarginsGuide.leadingAnchor).isActive = true
|
|
stackViewButtons.trailingAnchor.constraint(equalTo: containerView.layoutMarginsGuide.trailingAnchor).isActive = true
|
|
|
|
previousView = stackViewButtons
|
|
if displayType == .mapExpanded {
|
|
containerView.addSubview(mapView)
|
|
mapView.heightAnchor.constraint(equalToConstant: 140.0).isActive = true
|
|
mapView.topAnchor.constraint(equalTo: stackViewButtons.bottomAnchor, constant: Self.DefaultVerticalSpacing).isActive = true
|
|
mapView.leadingAnchor.constraint(equalTo: containerView.layoutMarginsGuide.leadingAnchor).isActive = true
|
|
mapView.trailingAnchor.constraint(equalTo: containerView.layoutMarginsGuide.trailingAnchor).isActive = true
|
|
|
|
previousView = mapView
|
|
} else if displayType == .weatherExpanded {
|
|
let weatherTitleLabel = UILabel()
|
|
weatherTitleLabel.translatesAutoresizingMaskIntoConstraints = false
|
|
weatherTitleLabel.text = NSLocalizedString("weather_weather", comment: "")
|
|
weatherTitleLabel.font = UIFont.preferredFont(forTextStyle: .headline)
|
|
|
|
containerView.addSubview(weatherTitleLabel)
|
|
weatherTitleLabel.topAnchor.constraint(equalTo: stackViewButtons.bottomAnchor, constant: Self.DefaultVerticalSpacing).isActive = true
|
|
weatherTitleLabel.leadingAnchor.constraint(equalTo: containerView.layoutMarginsGuide.leadingAnchor).isActive = true
|
|
weatherTitleLabel.trailingAnchor.constraint(equalTo: containerView.layoutMarginsGuide.trailingAnchor).isActive = true
|
|
|
|
containerView.addSubview(weatherInfoLabel)
|
|
containerView.addSubview(weatherImageView)
|
|
weatherImageView.heightAnchor.constraint(equalToConstant: 60.0).isActive = true
|
|
weatherImageView.widthAnchor.constraint(equalTo: weatherImageView.heightAnchor).isActive = true
|
|
weatherImageView.leadingAnchor.constraint(equalTo: containerView.layoutMarginsGuide.leadingAnchor).isActive = true
|
|
weatherImageView.trailingAnchor.constraint(equalTo: weatherInfoLabel.leadingAnchor, constant: -8.0).isActive = true
|
|
weatherImageView.centerYAnchor.constraint(equalTo: weatherInfoLabel.centerYAnchor).isActive = true
|
|
|
|
weatherInfoLabel.topAnchor.constraint(equalTo: weatherTitleLabel.bottomAnchor, constant: 4.0).isActive = true
|
|
weatherInfoLabel.trailingAnchor.constraint(equalTo: containerView.layoutMarginsGuide.trailingAnchor).isActive = true
|
|
|
|
previousView = weatherInfoLabel
|
|
}
|
|
|
|
if (displayType == .mapExpanded || displayType == .weatherExpanded) {
|
|
let buttonClose = createRoundedButton(title: NSLocalizedString("CHIUDI", comment: ""), action: #selector(closeTapped(_:)))
|
|
|
|
containerView.addSubview(buttonClose)
|
|
buttonClose.topAnchor.constraint(equalTo: previousView.bottomAnchor, constant: Self.DefaultVerticalSpacing).isActive = true
|
|
buttonClose.leadingAnchor.constraint(equalTo: containerView.layoutMarginsGuide.leadingAnchor).isActive = true
|
|
buttonClose.trailingAnchor.constraint(equalTo: containerView.layoutMarginsGuide.trailingAnchor).isActive = true
|
|
buttonClose.bottomAnchor.constraint(equalTo: containerView.layoutMarginsGuide.bottomAnchor).isActive = true
|
|
}
|
|
else {
|
|
stackViewButtons.bottomAnchor.constraint(equalTo: containerView.layoutMarginsGuide.bottomAnchor).isActive = true
|
|
}
|
|
}
|
|
|
|
private func recreateUI() {
|
|
// remove all subviews and recreate the required components
|
|
containerView.subviews.forEach({ $0.removeFromSuperview() })
|
|
setupUI()
|
|
}
|
|
|
|
private func updateUI() {
|
|
guard let seismic = seismic else { return }
|
|
|
|
containerView.backgroundColor = colors?.startColor
|
|
|
|
let notified = couldBeNotified(for: seismic)
|
|
titleImageView.image = notified ? UIImage(named: "bell") : UIImage(named: "bell_disabled")
|
|
|
|
// update seismic data
|
|
placeLabel.text = seismic.place
|
|
networkLabel.text = seismic.provider
|
|
magnitudeLabel.textColor = colors?.textColor
|
|
if informationTypes.contains(.preliminary) {
|
|
let lowerValue = seismic.magnitude.doubleValue - seismic.magnitudeRange.doubleValue/2.0
|
|
let upperValue = seismic.magnitude.doubleValue + seismic.magnitudeRange.doubleValue/2.0
|
|
magnitudeLabel.text = String(format: "%.1f-%.1fM", lowerValue, upperValue)
|
|
depthLabel.text = ""
|
|
} else {
|
|
magnitudeLabel.text = "\(seismic.magnitude)ML"
|
|
depthLabel.text = "\(NSLocalizedString("Profondità", comment: "")): \(seismic.depth) km"
|
|
}
|
|
|
|
let formattedDate = Self.dateFormatter.string(from: seismic.date)
|
|
let timeSuffix = seismic.timeDifference > 60 ? NSLocalizedString("ore fa", comment: "") : NSLocalizedString("minuti fa", comment: "")
|
|
let timeRounded = seismic.timeDifference > 60 ? Int(round(seismic.timeDifference / 60)) : Int(seismic.timeDifference)
|
|
timeLabel.text = "🕗 \(formattedDate) - \(timeRounded) \(timeSuffix)"
|
|
let distanceRounded = Int(round(seismic.userDistance))
|
|
distanceLabel.text = "📐 \(distanceRounded) km \(NSLocalizedString("dalla tua posizione", comment: ""))"
|
|
let coordinateText = coordinateString(coordinate: seismic.coordinate.coordinate)
|
|
coordinateLabel.text = "🌍 \(coordinateText)"
|
|
|
|
// evaluate population string
|
|
let populationIsRed = seismic.population100km >= 1_000_000 || seismic.userDistance <= 250
|
|
let population = formatPopulation(seismic.population100km)
|
|
populationLabel.text = "👨👩👦 \(population) \(NSLocalizedString("share_radius100", comment: ""))"
|
|
populationLabel.textColor = populationIsRed ? AppTheme.Colors.red : .black
|
|
|
|
if seismic.smartphoneNumber.intValue > 0 || true {
|
|
smartphonesLabel.text = String(format: NSLocalizedString("official_smartphones", comment: ""), seismic.smartphoneNumber)
|
|
}
|
|
if seismic.userNumber.intValue > 0 || true {
|
|
alertsLabel.text = String(format: NSLocalizedString("official_reports", comment: ""), seismic.userNumber)
|
|
}
|
|
|
|
if displayType == .mapExpanded {
|
|
// zoom based on population involved
|
|
let zoom = mapZoomFor(population: seismic.population100km)
|
|
let span = MKCoordinateSpan(latitudeDelta: zoom, longitudeDelta: zoom)
|
|
let region = MKCoordinateRegion(center: seismic.coordinate.coordinate, span: span)
|
|
|
|
mapView.setCenter(seismic.coordinate.coordinate, animated: false)
|
|
mapView.setRegion(region, animated: false)
|
|
|
|
// add a pin on the center
|
|
let annotation = MKPointAnnotation()
|
|
annotation.coordinate = seismic.coordinate.coordinate
|
|
annotation.title = ""
|
|
mapView.addAnnotation(annotation)
|
|
} else if displayType == .weatherExpanded {
|
|
weatherInfoLabel.text = ""
|
|
+ String(format: NSLocalizedString("weather_temperature", comment: ""), seismic.weatherTemperature.doubleValue - EQNMathKelvin) + "\n"
|
|
+ String(format: NSLocalizedString("weather_pressure", comment: ""), seismic.weatherPressure) + "\n"
|
|
+ String(format: NSLocalizedString("weather_windspeed", comment: ""), seismic.weatherWindSpeed) + "\n"
|
|
+ String(format: NSLocalizedString("weather_humidity", comment: ""), seismic.weatherHumidity) + "\n"
|
|
+ String(format: NSLocalizedString("weather_clouds", comment: ""), seismic.weatherCloud)
|
|
weatherImageView.image = UIImage(named: "weather_\(seismic.weatherIcon).png")
|
|
}
|
|
}
|
|
|
|
// MARK: - Public
|
|
|
|
/// Configure the cell to display a seismic
|
|
/// - Parameters:
|
|
/// - seismic: Seismic to display
|
|
/// - type: Type of cell
|
|
/// - informations: Informations to show
|
|
public func configure(with seismic: EQNSisma, type: DisplayType, informations: [InformationType]) {
|
|
self.seismic = seismic
|
|
self.colors = calculateColors(for: seismic.magnitude.doubleValue)
|
|
self.displayType = type
|
|
self.informationTypes = informations
|
|
|
|
if !informations.contains(.time) {
|
|
self.informationTypes += [.time]
|
|
}
|
|
|
|
if seismic.preliminary.intValue > 0 && !informations.contains(.preliminary) {
|
|
self.informationTypes += [.preliminary]
|
|
}
|
|
if seismic.smartphoneNumber.intValue > 0 && !informations.contains(.realtimeSmartphones) {
|
|
self.informationTypes += [.realtimeSmartphones]
|
|
}
|
|
if seismic.userNumber.intValue > 0 && !informations.contains(.reportUsers) {
|
|
self.informationTypes += [.reportUsers]
|
|
}
|
|
|
|
recreateUI()
|
|
updateUI()
|
|
setNeedsLayout()
|
|
layoutIfNeeded()
|
|
}
|
|
|
|
/// Creates a snapshot of the current cell
|
|
/// - Returns: Image with the snapshot of the cell
|
|
public func createSnapshot() -> UIImage {
|
|
let renderer = UIGraphicsImageRenderer(size: contentView.bounds.size)
|
|
let image = renderer.image { ctx in
|
|
contentView.drawHierarchy(in: contentView.bounds, afterScreenUpdates: true)
|
|
}
|
|
return image
|
|
}
|
|
|
|
// MARK: - Actions
|
|
|
|
@objc func shareTapped(_ sender: UIButton) {
|
|
delegate?.seismicNetworkCellDidTapShare(self)
|
|
}
|
|
|
|
@objc func mapTapped(_ sender: UIButton) {
|
|
if displayType != .mapExpanded {
|
|
delegate?.seismicNetworkCellDidTapMap(self)
|
|
}
|
|
}
|
|
|
|
@objc func weatherTapped(_ sender: UIButton) {
|
|
if displayType != .weatherExpanded {
|
|
delegate?.seismicNetworkCellDidTapWeather(self)
|
|
}
|
|
}
|
|
|
|
@objc func calendarTapped(_ sender: UIButton) {
|
|
delegate?.seismicNetworkCellDidTapCalendar(self)
|
|
}
|
|
|
|
@objc func settingsTapped(_ sender: UIButton) {
|
|
delegate?.seismicNetworkCellDidTapSettings(self)
|
|
}
|
|
|
|
@objc func closeTapped(_ sender: UIButton) {
|
|
delegate?.seismicNetworkCellDidTapClose(self)
|
|
}
|
|
|
|
// MARK: - Helpers
|
|
|
|
@discardableResult
|
|
private func addSeparator(constraintTo: NSLayoutYAxisAnchor, constanst: CGFloat = 8.0) -> UIView {
|
|
let separator = UIView()
|
|
separator.translatesAutoresizingMaskIntoConstraints = false
|
|
separator.backgroundColor = .lightGray
|
|
containerView.addSubview(separator)
|
|
|
|
separator.topAnchor.constraint(equalTo: constraintTo, constant: constanst).isActive = true
|
|
separator.leadingAnchor.constraint(equalTo: containerView.layoutMarginsGuide.leadingAnchor).isActive = true
|
|
separator.trailingAnchor.constraint(equalTo: containerView.layoutMarginsGuide.trailingAnchor).isActive = true
|
|
separator.heightAnchor.constraint(equalToConstant: 1.0).isActive = true
|
|
|
|
return separator
|
|
}
|
|
|
|
private func createRoundedButton(title: String, action: Selector) -> EQNRoundedButton {
|
|
let button = EQNRoundedButton(frame: .zero)
|
|
button.translatesAutoresizingMaskIntoConstraints = false
|
|
button.addTarget(self, action: action, for: .touchUpInside)
|
|
button.setTitle(title, for: .normal)
|
|
button.setTitleColor(AppTheme.Colors.darkGray, for: .normal)
|
|
button.backgroundColor = UIColor.white.withAlphaComponent(0.5)
|
|
return button
|
|
}
|
|
|
|
/// Check if the user could be received a notification for this seismic
|
|
private func couldBeNotified(for seismic: EQNSisma) -> Bool {
|
|
let settings = EQNNotificheReteSismiche.shared()
|
|
|
|
if !settings.isAbilitato {
|
|
return false
|
|
}
|
|
|
|
if !settings.listaEnti.contains(seismic.provider) {
|
|
return false
|
|
}
|
|
|
|
var notified = true
|
|
if let radius = Double(settings.distanzaPosizione), seismic.userDistance > radius {
|
|
notified = false
|
|
}
|
|
if let magnitude = Double(settings.energiaSisma), seismic.magnitude.doubleValue < magnitude {
|
|
notified = false
|
|
}
|
|
|
|
if settings.isAbilitaVicini, seismic.userDistance < 50 {
|
|
notified = true
|
|
}
|
|
|
|
if settings.isTerremortiForti, let strongMagnitude = Double(settings.energiaTerremotiForti), seismic.magnitude.doubleValue >= strongMagnitude {
|
|
notified = true
|
|
}
|
|
|
|
return notified
|
|
}
|
|
|
|
/// Convert coordinates in degrees
|
|
private func coordinateString(coordinate: CLLocationCoordinate2D) -> String {
|
|
var latSeconds = Int(coordinate.latitude * 3600)
|
|
let latDegrees = latSeconds / 3600
|
|
latSeconds = abs(latSeconds % 3600)
|
|
let latMinutes = latSeconds / 60
|
|
latSeconds %= 60
|
|
var longSeconds = Int(coordinate.longitude * 3600)
|
|
let longDegrees = longSeconds / 3600
|
|
longSeconds = abs(longSeconds % 3600)
|
|
let longMinutes = longSeconds / 60
|
|
longSeconds %= 60
|
|
return String(format:"%d°%d'%d\"%@ lat %d°%d'%d\"%@ lon",
|
|
abs(latDegrees),
|
|
latMinutes,
|
|
latSeconds, latDegrees >= 0 ? "N" : "S",
|
|
abs(longDegrees),
|
|
longMinutes,
|
|
longSeconds,
|
|
longDegrees >= 0 ? "E" : "W" )
|
|
}
|
|
|
|
/// Determines the zoom for the map, based on the involved population
|
|
private func mapZoomFor(population: Double) -> CLLocationDegrees {
|
|
var zoom: CLLocationDegrees = 1
|
|
if population > 1_000_000 {
|
|
zoom = 7
|
|
} else if population < 500 {
|
|
zoom = 3
|
|
} else {
|
|
zoom = 5
|
|
}
|
|
return zoom
|
|
}
|
|
|
|
/// Format population value (ex. 1.5M, 2.4k)
|
|
private func formatPopulation(_ population: Double) -> String {
|
|
var populationString = ""
|
|
if population > 999_999 {
|
|
let roundedPopulation = round(population / 100_000) / 10
|
|
populationString = "\(roundedPopulation)M"
|
|
} else if population > 999 {
|
|
let roundedPopulation = round(population / 100) / 10
|
|
populationString = "\(roundedPopulation)K"
|
|
} else {
|
|
let roundedPopulation = round(population)
|
|
populationString = "\(roundedPopulation)"
|
|
}
|
|
return populationString
|
|
}
|
|
|
|
/// Calculate colors to use for text and background of the cell
|
|
private func calculateColors(for magnitude: Double) -> MagnitudeColors {
|
|
var textColor = UIColor.black
|
|
|
|
var r = 0, g = 0, b = 0
|
|
if (magnitude < 2.0) {
|
|
let fraction: Double = 1 - (magnitude - 0.0) / (2.0 - 0.0)
|
|
r = Int(round(200.0 + (255.0 - 200.0) * fraction))
|
|
g = Int(round(226.0 + (255.0 - 226.0) * fraction))
|
|
b = Int(round(196.0 + (255.0 - 196.0) * fraction))
|
|
textColor = UIColor(red: 12.0 / 255.0, green: 115.0 / 255.0, blue: 16.0 / 255.0, alpha: 1.0)
|
|
}
|
|
if (magnitude >= 2.0 && magnitude < 3.5) {
|
|
let fraction: Double = 1 - (magnitude - 2) / (3.5 - 2)
|
|
r = Int(round(136.0 + (200.0 - 136.0) * fraction))
|
|
g = Int(round(175.0 + (226.0 - 175.0) * fraction))
|
|
b = Int(round(131.0 + (196.0 - 131.0) * fraction))
|
|
textColor = UIColor(red: 12.0 / 255.0, green: 160.0 / 255.0, blue: 35.0 / 255.0, alpha: 1.0)
|
|
}
|
|
if (magnitude >= 3.5 && magnitude < 4.5) {
|
|
let fraction: Double = 1 - (magnitude - 3.5) / (4.5 - 3.5)
|
|
r = 252
|
|
g = Int(round(233.0 + (253.0 - 233.0) * fraction))
|
|
b = Int(round(179.0 + (209.0 - 179.0) * fraction))
|
|
textColor = UIColor(red: 244.0 / 255.0, green: 195.0 / 255.0, blue: 0.0 / 255.0, alpha: 1.0)
|
|
}
|
|
if (magnitude >= 4.5 && magnitude < 5.5) {
|
|
let fraction: Double = 1 - (magnitude - 4.5) / (5.5 - 4.5)
|
|
r = 252
|
|
g = Int(round(159.0 + (197.0 - 159.0) * fraction))
|
|
b = Int(round(161.0 + (197.0 - 161.0) * fraction))
|
|
textColor = UIColor(red: 255.0 / 255.0, green: 0.0 / 255.0, blue: 0.0 / 255.0, alpha: 1.0)
|
|
}
|
|
if (magnitude >= 5.5) {
|
|
let fraction: Double = 1 - (magnitude - 5.5) / (10 - 5.5)
|
|
r = Int(round(190.0 + (254.0 - 190.0) * fraction))
|
|
g = Int(round(124.0 + (219.0 - 124.0) * fraction))
|
|
b = 255
|
|
textColor = UIColor(red: 183.0 / 255.0, green: 60.0 / 255.0, blue: 252.0 / 255.0, alpha: 1.0)
|
|
}
|
|
|
|
let r2 = min(r + 30, 255)
|
|
let g2 = min(g + 30, 255)
|
|
let b2 = min(b + 30, 255)
|
|
|
|
let startColor = UIColor(red: CGFloat(r) / 255.0, green: CGFloat(g) / 255.0, blue: CGFloat(b) / 255.0, alpha: 1.0)
|
|
let endColor = UIColor(red: CGFloat(r2) / 255.0, green: CGFloat(g2) / 255.0, blue: CGFloat(b2) / 255.0, alpha: 1.0)
|
|
|
|
return (textColor: textColor, startColor: startColor, endColor: endColor)
|
|
}
|
|
}
|