SwiftでTwitter API v2を使ってみよう（MVVM風）

import SwiftUI

struct TweetView: View {

    // ViewとViewModelをバインド(ViewModel側で変更したらView側も変わる)させたいので、@ObservedObjectをつける。
    @ObservedObject private var tweetVm = TweetViewModel() 

    // 画面上での変更を監視したいので、＠Stateをつける。

    @State private var tweetWord: String = ""
    @State private var tweetId: String = ""
    @State private var searchType: Int = 0
    @State private var withTweetDetail: Bool = false

    var body: some View {


        VStack{
            Picker(selection: $searchType, label: Text("検索方法を選択")) {
                Text("IDで検索").tag(0)
                Text("ワードで検索").tag(1)

            }.pickerStyle(SegmentedPickerStyle())
            .frame(width: 400)


            Toggle(isOn: $withTweetDetail) {
                Text(withTweetDetail ? "指標も一緒に！" : "指標はいらないよ")
            }.frame(width: 350, height: 50)


            if (searchType == 1) {
                TextField(
                    "調べたいワードを入力してね",
                    text: $tweetWord

                )
                .frame(width: 350, height: 50)
                .font(.caption2)
                .textFieldStyle(RoundedBorderTextFieldStyle())


                HStack{
                    Button(action: {
                        // ViewModelで設定された関数を呼び出す
                        tweetVm.searchTweets(keyword: self.tweetWord,withTweetDetail: self.withTweetDetail)
                    }, label: {
                        Text("検索")
                    })

                    if (tweetVm.nextToken != "") {
                        Button(action: {
                            tweetVm.searchTweets(keyword: self.tweetWord,withTweetDetail: self.withTweetDetail, isNext: true)

                        }, label: {
                            Text("次の10件>>")
                        })
                    }
                }
            } else {

                TextField(
                    "IDを入力してね",
                    text: $tweetId
                )
                .frame(width: 350, height: 50)
                .font(.caption2)
                .textFieldStyle(RoundedBorderTextFieldStyle())

                HStack{
                    Button(action: {
                        // ViewModel側で設定された関数を呼び出す。
                        tweetVm.searchById(id: self.tweetId, withTweetDetail: self.withTweetDetail)
                    }, label: {
                        Text("検索")
                    })
                }




            }
        }

　　　　　　　　　　　　　　　
        List(tweetVm.tweets) { tweet in
            VStack{
                HStack{

                    Text("ツイートID")
                        .font(.caption)
                        .bold()
                    Text(tweet.tweetId)
                        .font(.caption2)
                }
                Text(tweet.text)
                    .font(.headline)
                    .multilineTextAlignment(.leading)

                // 後で出てくるけれど、public_metrics　＝ ツイートの指標で、検索条件に含めるかどうかによってデータがあるかnilかが変わるよ。
                // データがあるときだけ表示するために下記のような書き方をするよ。
                if let i = tweet.public_metrics {

                    HStack {
                        Label(String((tweet.public_metrics?.reply_count)!),
                              systemImage: "message")
                            .font(.caption)
                            .foregroundColor(.green)

                        Label(String((tweet.public_metrics?.retweet_count)!),
                              systemImage: "arrow.2.squarepath")
                            .font(.caption)
                            .foregroundColor(.green)
                        Label(String((tweet.public_metrics?.quote_count)!),
                              systemImage: "pencil")
                            .font(.caption)
                            .foregroundColor(.green)



                        Label(String((tweet.public_metrics?.like_count)!),
                              systemImage: "heart.fill")
                            .font(.caption)
                            .foregroundColor(.green)


                    }

                }
            }
        }
       　// ViewModel側でアラートを設定して表示するために使用しているよ。
        .alert(isPresented: $tweetVm.isShowError ) {
            tweetVm.alert
        }
    }
}

struct TweetView_Previews: PreviewProvider {
    static var previews: some View {
        TweetView()
    }
}

import Foundation
import Combine
import SwiftUI

class TweetViewModel: ObservableObject {


    // View画面でも使用されているbindされている値だよ。
    // TweetModelについては後述します。
    @Published var tweets: [TweetModel] = []
    @Published var nextToken: String = ""
    @Published var isShowError: Bool = false
    @Published var alert: Alert = Alert(title: Text(""))


    var cancellationToken: AnyCancellable?
    var exKeyword: String = "";

    // ApiSetting.swiftの説明時に詳しく書きますが、URLを取得する関数です。
    let url = ApiSetting().getConnectURL();

    // ApiFetcher.swiftの説明時に詳しく書きます。
    let fetcher = ApiFetcher();


　　　　　　　　// IDで検索する1・２の場合 (TweetLookup)の関数だよ
    func searchById(id: String, withTweetDetail: Bool) {

　　　　　　　　　　　　　　　　　// Viewで設定したアラートはここで設定しているよ。
　　　　　　　　　　　　　　　　// バリデーションチェックなどをここで行うイメージだよ。
        if (id == "") {
            isShowError = true
            alert = Alert(title: Text("検索条件はかならず入力してください☺️"))
            return;
        }

        var keywords:[String: String] = ["ids": id]

        //　指標を取得する場合は、expansionsとtweet.fieldsの2つを引数として追加するよ。
        if (withTweetDetail) {
            keywords["expansions"]  = "author_id"
            keywords["tweet.fields"] = "public_metrics"
        }

        // ApiFetcher.swiftの関数を呼び出しているよ。
　　　　　　　　　　　　　　　　// 引数のpathはApiSetting.swiftで設定している値です。
        cancellationToken = self.fetcher.searchTweetsRequest(path:.searchById, baseUrl: url, keywords: keywords)
            // ApiFetcherからエラーが戻ってきた場合、それをアラートとして表示するように設定
            .mapError({error -> AppError in
                self.isShowError = true
                self.alert = Alert(title: Text(error.errorDescription!))
                return error
            })
            .sink(receiveCompletion: { completion in

                switch completion {
                case .finished:
                    break
                case .failure(_):
                    break
                }
            }, receiveValue: { row in

                // IDで取得する場合と、keywordで取得する場合で返り値が異なるのに注意！
                if (row.data != nil) {

                    self.tweets = row.data!;

                } else {
                    self.isShowError = true
                    self.alert = Alert(title: Text("一致するツイートが見つかりませんでした"))
                    self.tweets = []
                }

            })

    }


    // キーワードで検索する3・４の場合(Tweet recent searchh)ときの関数だよ。
    func searchTweets(keyword: String, withTweetDetail:Bool,isNext: Bool = false) {

        if (keyword == "") {
            isShowError = true
            alert = Alert(title: Text("検索条件はかならず入力してください☺️"))
            return;
        }


        var keywords:[String: String] = ["query": keyword]


        // キーワードで取得する場合は、1回のAPIコールで10件まで取得できるよ。
        // 続きから取得したい場合は、next_tokenの引数を追加して上げる必要があるよ。
        if (self.nextToken != ""  && exKeyword == keyword && isNext) {
            keywords["next_token"] = self.nextToken
        }

        if (withTweetDetail) {
            keywords["expansions"]  = "author_id"
            keywords["tweet.fields"] = "public_metrics"
        }
        exKeyword = keyword

　　　　　　　　　　　　　　　　// ApiFetcher.swiftの関数を呼び出しているよ。
　　　　　　　　　　　　　　　// 引数のpathはApiSetting.swiftで設定している値です。
        cancellationToken = self.fetcher.searchTweetsRequest(path: .searchTweets, baseUrl: url, keywords: keywords)
            .mapError({error -> AppError in

                return error
            })
            .sink(receiveCompletion: { completion in

                switch completion {
                case .finished:
                    break
                case .failure(_):
                    break
                }
            }, receiveValue: { row in
                // IDとkeywordで取得する場合には戻り値が異なるため、注意!
                if (row.meta!.result_count > 0) {
                    self.tweets = row.data!;
                    self.nextToken = row.meta!.next_token!;

                } else {
                    self.isShowError = true
                    self.alert = Alert(title: Text("一致するツイートが見つかりませんでした"))
                    self.tweets = []
                    self.nextToken = "";

                }
            })

    }


}

import Foundation
import SwiftUI


struct ApiSetting {

    private static let PrivateUrl     = URL(string: "https://api.twitter.com/2/")!
    static let BearerToken = XX-自分で取得したTokenを設定。-XX;


    //　今回はTwitterのURLだけだけど、実際には引数も持たせて、
    // 本番環境とテスト環境のどちらにアクセスするかを変えていました。
    func getConnectURL() ->URL {
        return ApiSetting.PrivateUrl;
    }
    // pathで使用していた共通URL以下のアドレスです。
    // IDで検索するときはhttps://api.twitter.com/2/tweets
    // キーワードで検索するときは、https://api.twitter.com/2/tweets/search/recentをURLとして使用していました。
    enum ApiPath: String {
        case searchById = "tweets"
        case searchTweets = "tweets/search/recent"

    }

}

import Foundation
import Combine
import os

// ViewModel側から呼び出されていたのはこちらになります。
class ApiFetcher {

    var apiClient    = ApiClient()

    /* CALL  API : api/TweetRequest */
　　　　　　　　// ポイント①
    func searchTweetsRequest(path: ApiSetting.ApiPath,baseUrl: URL, keywords: [String: String]) -> AnyPublisher<TweetsResponse, AppError> {

        // ベースとなるurlに、APIごとのpathを合体させます。
        var url = baseUrl.appendingPathComponent(path.rawValue)

        guard var components = URLComponents(url: url, resolvingAgainstBaseURL: true)
        else { return Fail(error: AppError.invalidUrl).eraseToAnyPublisher()}


        // queryの引数に追加する項目を設定
        // 例えば、query=猫で検索したい場合、 URLQueryItem(name: "query", value="猫")とすることで、URLにもたせています。
        components.queryItems = keywords.map {(key,value) in
            URLQueryItem(name:key, value: value )
        }

        var request = URLRequest(url: components.url!)
        //　今回はすべてGETなので下記のように設定
        request.httpMethod = "GET"

        //Twitter APIを使うのに必要なBearerを設定します。Token自体は先述のApiSettingにて設定されている値を参照しています。
        request.setValue( "Bearer \(ApiSetting.BearerToken)", forHTTPHeaderField: "Authorization")

        // ApiClient.swiftに続く
        return apiClient.run(with: request)
            .map(\.value)
            .eraseToAnyPublisher()
    }
}

import Foundation
import Combine
import os

class ApiClient {

    let logger = Logger()

    struct Response<T> {
        let value: T
        let response: URLResponse
    }

　　　　　　　　//　ポイント②
    func run<T: Decodable>(with request: URLRequest) -> AnyPublisher<Response<T>, AppError> {

        return URLSession.shared
            .dataTaskPublisher(for: request)
            .tryMap { (data,urlResponse) -> Response<T> in

                // APIのステータスコードによって、画面に現れるエラーが変わるようにしています。
                // アラートをそのまま出しても良いけれど、わかりやすい言葉に変えたほうがいいかなーということでここで変換をしています。
                // ApiErrorについては、後述します。

                if let httpUrlResponse = urlResponse as? HTTPURLResponse {

                    self.logger.info("urlResponse.statusCode = \(httpUrlResponse.statusCode)")


                    if httpUrlResponse.statusCode != 200  {

                        switch httpUrlResponse.statusCode {
                        case 401:
                            throw AppError.unauthorizedRequired

                        case 500:
                            throw AppError.serverError

                        case 501:
                            throw AppError.gatewayTimeout

                        default:
                            throw AppError.unexpectedNetworkError(code: httpUrlResponse.statusCode, message:error.localizedDescription)
                        }
                    }
                }

                do {
　　　　　　　　　　　　　　　　　　　　　　         // ポイント③
                    let values = try JSONDecoder().decode(T.self, from: data)

                    return Response(value: values, response: urlResponse)

                } catch {

                        throw AppError.unexpectedNetworkError(code: 69, message: error.localizedDescription)

                }

            }
            .mapError { $0 as! AppError}
            .receive(on: DispatchQueue.main)
            .eraseToAnyPublisher()
    }
}

import Foundation

struct TweetsResponse: Decodable {

    //　TweetModel.swiftを参照
    // APIの結果によって存在するかが異なるため、ない場合を想定し、「?(Optional型)」をつけます。
　　　　　　　　// こうすることで、存在しない場合はnilを返却してくれるようになります。
    var data: [TweetModel]?

    // TwitterAPIの場合、1回のAPIコールで一致するすべてのデータを取得できたようなときは、
　　　　　　　　// next_tokenの項目自体が戻り値からなくなります。なので、Optional型にしてあげる必要があります。
　
    struct Meta: Hashable,Codable {
        var result_count: Int
        var next_token: String?

    }

　　　　　　　
    var meta: Meta?

    enum CodingKeys: String, CodingKey {
        case data
        case meta
    }
}

import Foundation

struct TweetModel: Codable, Hashable, Identifiable{

    var id = UUID().uuidString
    var tweetId: String
    var text: String
    var author_id: String?

    struct publicMetrics: Hashable, Codable {
        var retweet_count: Int
        var reply_count: Int
        var like_count: Int
        var quote_count: Int
    }

    //詳細を取得しなかった場合には、この項目が存在しないため、？(Optional)をつけます。
    var public_metrics: publicMetrics?


    //　APIからの戻り値にidという項目があり、おそらく一意になるとは思いますが、
    // 念の為、画面上で扱う上では、idをtweetIdと名前を変えて、idはUUIDで生成した本当に一意な値に変えています。
    //　本当はキャメルケースとスネークケースも統一したいけれど、めんどくさくて断念・・。

    enum CodingKeys: String, CodingKey {
        case tweetId = "id"
        case text
        case author_id
        case public_metrics
    }

}

import Foundation

enum AppError: Error {

　　　　　　　　
    // 401
    case unauthorizedRequired
    // 500
    case serverError
    // 504
    case gatewayTimeout
    // else ApiCall error
    case unexpectedNetworkError(code: Int, message: String)
    // make URL Error
    case invalidUrl

    //session is not in Cookie
    case sessionError

    // Api status = false
    case apiCallFailed(message: String)
}

extension AppError: LocalizedError {
    var errorDescription: String? {
        switch self {

        case .unauthorizedRequired:
            return "ネットワーク認証に失敗しました。"
        case .serverError:
            return "サーバー側でエラーが起きました。お手数ですが担当者にご連絡ください。"
        case .gatewayTimeout:
            return "一定時間内に処理が完了しませんでした。もう一度お試しください。"

        case .unexpectedNetworkError(let code, let message):
            return "予期せぬネットワークエラーが発生しました(\(code) : \(message))"

        case .invalidUrl:
            return "無効なURLです"

        case .sessionError:
            return "ログインが必要です"

        case .apiCallFailed(let message) :
            return message

        default :
            return "予期せぬエラーです"
        }
    }
}