Movable Ink

class MovableInkUrl(private val url: String) {
    private data class Result(val url: String, val locationHeader: String?, val statusCode: Int)

    fun asFlow() = flow {
        emit(resolveDeepLink())
    }.flowOn(Dispatchers.IO)

    fun asLiveData(): LiveData<String?> {
        return asFlow()
            .catch {
                emit(null)
            }
            .asLiveData()
    }

    private fun resolveDeepLink(): String? {
        var result: Result = resolveUrl(url)

        while (true) {
            if (result.statusCode == 200) {
                return result.url
            }

            if (result.statusCode == 302) {
                val nextUrl = nextUrl(result.url, requireNotNull(result.locationHeader))
                if (shouldResolve(nextUrl)) {
                    result = resolveUrl(nextUrl)
                    continue
                } else {
                    return nextUrl
                }
            }

            return null
        }

        return null
    }

    private fun nextUrl(url: String, location: String): String {
        return if (Uri.parse(location).isRelative) {
            Uri.parse(url).buildUpon()
                .encodedPath(location)
                .build()
                .toString()
        } else {
            location
        }
    }

    private fun shouldResolve(url: String): Boolean {
        if (url == this.url) {
            return true
        }

        return URLUtil.isHttpsUrl(url)
    }

    private fun resolveUrl(url: String): Result {
        return with(URL(url).openConnection() as HttpURLConnection) {
            this.instanceFollowRedirects = false
            this.requestMethod = "HEAD"
            val l = getHeaderField("Location")
            disconnect()
            Result(url, l, responseCode)
        }
    }

}

class MovableInkActivity : AppCompatActivity() {

    internal lateinit var viewModel: UrlViewModel

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        Autopilot.automaticTakeOff(this)

        val url = intent.getStringExtra("url")
        val fallbackUrl = intent.getStringExtra("fallback")

        if (url == null) {
            finish()
            return
        }

        setContentView(createLayout())


        viewModel = ViewModelProvider(this, ViewModelFactory(url, fallbackUrl)).get(
            UrlViewModel::class.java
        )

        viewModel.result.observe(this) { result ->
            if (result != null) {
                UAirship.shared().deepLink(result)
            } else {
                // no deep link or fallback state
                // Toast.makeText(this, "Failed to resolve movable ink URL", Toast.LENGTH_SHORT).show()
            }

            finish()
        }
    }

    private fun createLayout(): View {
        val layout = FrameLayout(this)
        val progressBar = ProgressBar(this, null, android.R.attr.progressBarStyleLarge)
        progressBar.isIndeterminate = true

        val params: LinearLayout.LayoutParams =
            LinearLayout.LayoutParams(WRAP_CONTENT, WRAP_CONTENT)
        layout.addView(progressBar, params)

        return layout
    }

    companion object {
        fun launch(context: Context, url: String, fallbackUrl: String?) {
            val intent = Intent()
                .setClass(context, MovableInkActivity::class.java)
                .putExtra("url", url)
                .putExtra("fallback", fallbackUrl)
                .setFlags(Intent.FLAG_ACTIVITY_NEW_TASK)

            context.startActivity(intent)
        }
    }

    internal class UrlViewModel(private val url: String, private val fallbackUrl: String?) :
        ViewModel() {

        val result = MovableInkUrl(url).asFlow()
            .catch {
                emit(fallbackUrl)
            }
            .map {
                it ?: fallbackUrl
            }
            .asLiveData()
    }

    internal class ViewModelFactory(private val url: String, private val fallbackUrl: String?) :
        ViewModelProvider.Factory {

        override fun <T : ViewModel> create(modelClass: Class<T>): T {
            @Suppress("UNCHECKED_CAST") return UrlViewModel(url, fallbackUrl) as T
        }
    }
}

 airship.deepLinkListener = object : DeepLinkListener {
            override fun onDeepLink(deepLink: String): Boolean {
                if (deepLink.startsWith("https://mi.<MYDOMAIN>")) {
                    MovableInkActivity.launch(context, deepLink, null)
                    return true
                }

                ...

            }
        }

}
import Foundation

class MovableInkURL {
    private let url: URL
    private let delegate: TaskDelegate = TaskDelegate()

    private lazy var session : URLSession = {
        let config = URLSessionConfiguration.default
        return URLSession(configuration: config,
                          delegate: self.delegate,
                          delegateQueue: OperationQueue())
    }()

    init(url: URL) {
        self.url = url
    }

    public func resolve() async throws -> URL {
        var request = URLRequest(url: url)
        request.httpMethod = "HEAD"

        return try await withCheckedThrowingContinuation { continuation in
            let task = self.session.dataTask(with: request, completionHandler: { data, response, error in

                if let response = response as? HTTPURLResponse,
                   let locationHeader = response.value(forHTTPHeaderField: "Location"),
                   let url = URL(string: locationHeader) {
                    return continuation.resume(returning: url)
                } else if let url = response?.url {
                    return continuation.resume(returning: url)
                } else {
                    return continuation.resume(throwing: error ?? URLError(.badServerResponse))
                }
            })

            task.resume()
        }
    }

    private class TaskDelegate: NSObject, URLSessionTaskDelegate {
        func urlSession(_ session: URLSession,
                        task: URLSessionTask,
                        willPerformHTTPRedirection response:
                        HTTPURLResponse, newRequest request: URLRequest) async -> URLRequest? {

            guard let url = request.url,
                  url.absoluteString.lowercased().starts(with: "https")
            else {
                return nil
            }

            return request
        }
    }
}

import Foundation
import SwiftUI
import UIKit

class MovableInkAlert {

    static func openForURL(_ url: URL,
                          scene: UIWindowScene,
                          onResult: @escaping (URL?) -> Void) {

        var window: UIWindow?
        let view = MovableLoadingView(url: url) { url in
            window?.windowLevel = .normal
            window?.isHidden = true
            window = nil
            onResult(url)
        }

        let viewController = UIHostingController(rootView: view)
        viewController.view.backgroundColor = .clear
        viewController.modalPresentationStyle = .currentContext
        window = UIWindow(windowScene: scene)
        window?.rootViewController = viewController
        window?.windowLevel = .alert
        window?.makeKeyAndVisible()
    }

    fileprivate struct MovableLoadingView: View {

        let url: URL
        let onResult: ((URL?) -> Void)

        @ViewBuilder
        var body: some View {
            VStack {
                ProgressView()
                    .onAppear {
                        Task {
                            let url = try? await MovableInkURL(url: self.url).resolve()
                            await MainActor.run {
                                self.onResult(url)
                            }
                        }
                    }
                    .padding()
                    .background(Color(UIColor.systemBackground))
                    .cornerRadius(10)
            }
            .frame(maxWidth: .infinity, maxHeight: .infinity)
            .background(Color.gray.opacity(0.2))
        }
    }
}

    func receivedDeepLink(_ url: URL, completionHandler: @escaping () -> ()) {
        if (url.absoluteString.starts(with: "https://mi.<MYDOMAIN>")) {
            MovableInkAlert.openForURL(url, scene: try! Utils.findWindowScene()) { resolvedURL in
                // Navigate to resolvedURL or a fallbackURL
                completionHandler()
            }
            return
        }

        ...
    }