Convert some web repo and service classes to kotlin

app/src/main/java/awais/instagrabber/activities/MainActivity.kt

@@ -60,7 +60,6 @@ import awais.instagrabber.viewmodels.AppStateViewModel
 import awais.instagrabber.viewmodels.DirectInboxViewModel
 import awais.instagrabber.webservices.GraphQLService
 import awais.instagrabber.webservices.MediaService
-import awais.instagrabber.webservices.RetrofitFactory
 import awais.instagrabber.webservices.ServiceCallback
 import com.google.android.material.appbar.AppBarLayout
 import com.google.android.material.appbar.AppBarLayout.ScrollingViewBehavior
@@ -300,11 +299,11 @@ class MainActivity : BaseLanguageActivity(), FragmentManager.OnBackStackChangedL
             Log.e(TAG, "onDestroy: ", e)
         }
         unbindActivityCheckerService()
-        try {
+        // try {
-            RetrofitFactory.getInstance().destroy()
+        //     RetrofitFactory.getInstance().destroy()
-        } catch (e: Exception) {
+        // } catch (e: Exception) {
-            Log.e(TAG, "onDestroy: ", e)
+        //     Log.e(TAG, "onDestroy: ", e)
-        }
+        // }
         instance = null
     }
 

app/src/main/java/awais/instagrabber/repositories/DirectMessagesRepository.kt

@@ -1,155 +1,182 @@
-package awais.instagrabber.repositories;
+package awais.instagrabber.repositories
-
-import java.util.Map;
-
-import awais.instagrabber.repositories.responses.directmessages.DirectBadgeCount;
-import awais.instagrabber.repositories.responses.directmessages.DirectInboxResponse;
-import awais.instagrabber.repositories.responses.directmessages.DirectItemSeenResponse;
-import awais.instagrabber.repositories.responses.directmessages.DirectThread;
-import awais.instagrabber.repositories.responses.directmessages.DirectThreadBroadcastResponse;
-import awais.instagrabber.repositories.responses.directmessages.DirectThreadDetailsChangeResponse;
-import awais.instagrabber.repositories.responses.directmessages.DirectThreadFeedResponse;
-import awais.instagrabber.repositories.responses.directmessages.DirectThreadParticipantRequestsResponse;
-import awais.instagrabber.repositories.responses.directmessages.RankedRecipientsResponse;
-import retrofit2.Call;
-import retrofit2.http.FieldMap;
-import retrofit2.http.FormUrlEncoded;
-import retrofit2.http.GET;
-import retrofit2.http.POST;
-import retrofit2.http.Path;
-import retrofit2.http.Query;
-import retrofit2.http.QueryMap;
-
-public interface DirectMessagesRepository {
 
+import awais.instagrabber.repositories.responses.directmessages.*
+import retrofit2.Call
+import retrofit2.http.*
+
+interface DirectMessagesRepository {
     @GET("/api/v1/direct_v2/inbox/")
-    Call<DirectInboxResponse> fetchInbox(@QueryMap Map<String, Object> queryMap);
+    fun fetchInbox(@QueryMap queryMap: Map<String, String>): Call<DirectInboxResponse?>
 
     @GET("/api/v1/direct_v2/pending_inbox/")
-    Call<DirectInboxResponse> fetchPendingInbox(@QueryMap Map<String, Object> queryMap);
+    fun fetchPendingInbox(@QueryMap queryMap: Map<String, String>): Call<DirectInboxResponse?>
 
     @GET("/api/v1/direct_v2/threads/{threadId}/")
-    Call<DirectThreadFeedResponse> fetchThread(@Path("threadId") String threadId,
+    fun fetchThread(
-                                               @QueryMap Map<String, Object> queryMap);
+        @Path("threadId") threadId: String,
+        @QueryMap queryMap: Map<String, String>,
+    ): Call<DirectThreadFeedResponse?>
 
     @GET("/api/v1/direct_v2/get_badge_count/?no_raven=1")
-    Call<DirectBadgeCount> fetchUnseenCount();
+    fun fetchUnseenCount(): Call<DirectBadgeCount?>
 
     @FormUrlEncoded
     @POST("/api/v1/direct_v2/threads/broadcast/{item}/")
-    Call<DirectThreadBroadcastResponse> broadcast(@Path("item") String item,
+    fun broadcast(
-                                                  @FieldMap final Map<String, String> signedForm);
+        @Path("item") item: String,
+        @FieldMap signedForm: Map<String, String>,
+    ): Call<DirectThreadBroadcastResponse?>
 
     @FormUrlEncoded
     @POST("/api/v1/direct_v2/threads/{threadId}/add_user/")
-    Call<DirectThreadDetailsChangeResponse> addUsers(@Path("threadId") String threadId,
+    fun addUsers(
-                                                     @FieldMap final Map<String, String> form);
+        @Path("threadId") threadId: String,
+        @FieldMap form: Map<String, String>,
+    ): Call<DirectThreadDetailsChangeResponse?>
 
     @FormUrlEncoded
     @POST("/api/v1/direct_v2/threads/{threadId}/remove_users/")
-    Call<String> removeUsers(@Path("threadId") String threadId,
+    fun removeUsers(
-                             @FieldMap final Map<String, String> form);
+        @Path("threadId") threadId: String,
+        @FieldMap form: Map<String, String>,
+    ): Call<String?>
 
     @FormUrlEncoded
     @POST("/api/v1/direct_v2/threads/{threadId}/update_title/")
-    Call<DirectThreadDetailsChangeResponse> updateTitle(@Path("threadId") String threadId,
+    fun updateTitle(
-                                                        @FieldMap final Map<String, String> form);
+        @Path("threadId") threadId: String,
+        @FieldMap form: Map<String, String>,
+    ): Call<DirectThreadDetailsChangeResponse?>
 
     @FormUrlEncoded
     @POST("/api/v1/direct_v2/threads/{threadId}/add_admins/")
-    Call<String> addAdmins(@Path("threadId") String threadId,
+    fun addAdmins(
-                           @FieldMap final Map<String, String> form);
+        @Path("threadId") threadId: String,
+        @FieldMap form: Map<String, String>,
+    ): Call<String?>
 
     @FormUrlEncoded
     @POST("/api/v1/direct_v2/threads/{threadId}/remove_admins/")
-    Call<String> removeAdmins(@Path("threadId") String threadId,
+    fun removeAdmins(
-                              @FieldMap final Map<String, String> form);
+        @Path("threadId") threadId: String,
+        @FieldMap form: Map<String, String>,
+    ): Call<String?>
 
     @FormUrlEncoded
     @POST("/api/v1/direct_v2/threads/{threadId}/items/{itemId}/delete/")
-    Call<String> deleteItem(@Path("threadId") String threadId,
+    fun deleteItem(
-                            @Path("itemId") String itemId,
+        @Path("threadId") threadId: String,
-                            @FieldMap final Map<String, String> form);
+        @Path("itemId") itemId: String,
+        @FieldMap form: Map<String, String>,
+    ): Call<String?>
 
     @GET("/api/v1/direct_v2/ranked_recipients/")
-    Call<RankedRecipientsResponse> rankedRecipients(@QueryMap Map<String, String> queryMap);
+    fun rankedRecipients(@QueryMap queryMap: Map<String, String>): Call<RankedRecipientsResponse?>
 
     @FormUrlEncoded
     @POST("/api/v1/direct_v2/threads/broadcast/forward/")
-    Call<DirectThreadBroadcastResponse> forward(@FieldMap final Map<String, String> form);
+    fun forward(@FieldMap form: Map<String, String>): Call<DirectThreadBroadcastResponse?>
 
     @FormUrlEncoded
     @POST("/api/v1/direct_v2/create_group_thread/")
-    Call<DirectThread> createThread(@FieldMap final Map<String, String> signedForm);
+    fun createThread(@FieldMap signedForm: Map<String, String>): Call<DirectThread?>
 
     @FormUrlEncoded
     @POST("/api/v1/direct_v2/threads/{threadId}/mute/")
-    Call<String> mute(@Path("threadId") String threadId,
+    fun mute(
-                      @FieldMap final Map<String, String> form);
+        @Path("threadId") threadId: String,
+        @FieldMap form: Map<String, String>,
+    ): Call<String?>
 
     @FormUrlEncoded
     @POST("/api/v1/direct_v2/threads/{threadId}/unmute/")
-    Call<String> unmute(@Path("threadId") String threadId,
+    fun unmute(
-                        @FieldMap final Map<String, String> form);
+        @Path("threadId") threadId: String,
+        @FieldMap form: Map<String, String>,
+    ): Call<String?>
 
     @FormUrlEncoded
     @POST("/api/v1/direct_v2/threads/{threadId}/mute_mentions/")
-    Call<String> muteMentions(@Path("threadId") String threadId,
+    fun muteMentions(
-                              @FieldMap final Map<String, String> form);
+        @Path("threadId") threadId: String,
+        @FieldMap form: Map<String, String?>,
+    ): Call<String?>
 
     @FormUrlEncoded
     @POST("/api/v1/direct_v2/threads/{threadId}/unmute_mentions/")
-    Call<String> unmuteMentions(@Path("threadId") String threadId,
+    fun unmuteMentions(
-                                @FieldMap final Map<String, String> form);
+        @Path("threadId") threadId: String,
+        @FieldMap form: Map<String, String>,
+    ): Call<String?>
 
     @GET("/api/v1/direct_v2/threads/{threadId}/participant_requests/")
-    Call<DirectThreadParticipantRequestsResponse> participantRequests(@Path("threadId") String threadId,
+    fun participantRequests(
-                                                                      @Query("page_size") int pageSize,
+        @Path("threadId") threadId: String,
-                                                                      @Query("cursor") String cursor);
+        @Query("page_size") pageSize: Int,
+        @Query("cursor") cursor: String?,
+    ): Call<DirectThreadParticipantRequestsResponse?>
 
     @FormUrlEncoded
     @POST("/api/v1/direct_v2/threads/{threadId}/approve_participant_requests/")
-    Call<DirectThreadDetailsChangeResponse> approveParticipantRequests(@Path("threadId") String threadId,
+    fun approveParticipantRequests(
-                                                                       @FieldMap final Map<String, String> form);
+        @Path("threadId") threadId: String,
+        @FieldMap form: Map<String, String>,
+    ): Call<DirectThreadDetailsChangeResponse?>
 
     @FormUrlEncoded
     @POST("/api/v1/direct_v2/threads/{threadId}/deny_participant_requests/")
-    Call<DirectThreadDetailsChangeResponse> declineParticipantRequests(@Path("threadId") String threadId,
+    fun declineParticipantRequests(
-                                                                       @FieldMap final Map<String, String> form);
+        @Path("threadId") threadId: String,
+        @FieldMap form: Map<String, String>,
+    ): Call<DirectThreadDetailsChangeResponse?>
 
     @FormUrlEncoded
     @POST("/api/v1/direct_v2/threads/{threadId}/approval_required_for_new_members/")
-    Call<DirectThreadDetailsChangeResponse> approvalRequired(@Path("threadId") String threadId,
+    fun approvalRequired(
-                                                             @FieldMap final Map<String, String> form);
+        @Path("threadId") threadId: String,
+        @FieldMap form: Map<String, String>,
+    ): Call<DirectThreadDetailsChangeResponse?>
 
     @FormUrlEncoded
     @POST("/api/v1/direct_v2/threads/{threadId}/approval_not_required_for_new_members/")
-    Call<DirectThreadDetailsChangeResponse> approvalNotRequired(@Path("threadId") String threadId,
+    fun approvalNotRequired(
-                                                                @FieldMap final Map<String, String> form);
+        @Path("threadId") threadId: String,
+        @FieldMap form: Map<String, String>,
+    ): Call<DirectThreadDetailsChangeResponse?>
 
     @FormUrlEncoded
     @POST("/api/v1/direct_v2/threads/{threadId}/leave/")
-    Call<DirectThreadDetailsChangeResponse> leave(@Path("threadId") String threadId,
+    fun leave(
-                                                  @FieldMap final Map<String, String> form);
+        @Path("threadId") threadId: String,
+        @FieldMap form: Map<String, String>,
+    ): Call<DirectThreadDetailsChangeResponse?>
 
     @FormUrlEncoded
     @POST("/api/v1/direct_v2/threads/{threadId}/remove_all_users/")
-    Call<DirectThreadDetailsChangeResponse> end(@Path("threadId") String threadId,
+    fun end(
-                                                @FieldMap final Map<String, String> form);
+        @Path("threadId") threadId: String,
+        @FieldMap form: Map<String, String>,
+    ): Call<DirectThreadDetailsChangeResponse?>
 
     @FormUrlEncoded
     @POST("/api/v1/direct_v2/threads/{threadId}/approve/")
-    Call<String> approveRequest(@Path("threadId") String threadId,
+    fun approveRequest(
-                                @FieldMap final Map<String, String> form);
+        @Path("threadId") threadId: String,
+        @FieldMap form: Map<String, String>,
+    ): Call<String?>
 
     @FormUrlEncoded
     @POST("/api/v1/direct_v2/threads/{threadId}/decline/")
-    Call<String> declineRequest(@Path("threadId") String threadId,
+    fun declineRequest(
-                                @FieldMap final Map<String, String> form);
+        @Path("threadId") threadId: String,
+        @FieldMap form: Map<String, String>,
+    ): Call<String?>
 
     @FormUrlEncoded
     @POST("/api/v1/direct_v2/threads/{threadId}/items/{itemId}/seen/")
-    Call<DirectItemSeenResponse> markItemSeen(@Path("threadId") String threadId,
+    fun markItemSeen(
-                                              @Path("itemId") String itemId,
+        @Path("threadId") threadId: String,
-                                              @FieldMap final Map<String, String> form);
+        @Path("itemId") itemId: String,
+        @FieldMap form: Map<String, String>,
+    ): Call<DirectItemSeenResponse?>
 }

app/src/main/java/awais/instagrabber/webservices/CollectionService.java

@@ -32,7 +32,7 @@ public class CollectionService extends BaseService {
         this.deviceUuid = deviceUuid;
         this.csrfToken = csrfToken;
         this.userId = userId;
-        repository = RetrofitFactory.getInstance()
+        repository = RetrofitFactory.INSTANCE
                                     .getRetrofit()
                                     .create(CollectionRepository.class);
     }

app/src/main/java/awais/instagrabber/webservices/DirectMessagesService.kt

@@ -1,476 +1,483 @@
-package awais.instagrabber.webservices;
+package awais.instagrabber.webservices
-
+import awais.instagrabber.repositories.DirectMessagesRepository
-import androidx.annotation.NonNull;
+import awais.instagrabber.repositories.requests.directmessages.*
-import androidx.annotation.Nullable;
+import awais.instagrabber.repositories.responses.directmessages.*
-
+import awais.instagrabber.repositories.responses.giphy.GiphyGif
-import com.google.common.collect.ImmutableMap;
+import awais.instagrabber.utils.TextUtils.extractUrls
-
+import awais.instagrabber.utils.TextUtils.isEmpty
-import org.json.JSONArray;
+import awais.instagrabber.utils.Utils
-
+import org.json.JSONArray
-import java.util.Collection;
+import retrofit2.Call
-import java.util.HashMap;
+import java.util.*
-import java.util.List;
+class DirectMessagesService private constructor(
-import java.util.Map;
+    val csrfToken: String,
-import java.util.Objects;
+    val userId: Long,
-import java.util.UUID;
+    val deviceUuid: String,
-import java.util.stream.Collectors;
+) : BaseService() {
-
+    private val repository: DirectMessagesRepository = RetrofitFactory.retrofit.create(DirectMessagesRepository::class.java)
-import awais.instagrabber.repositories.DirectMessagesRepository;
+    fun fetchInbox(
-import awais.instagrabber.repositories.requests.directmessages.AnimatedMediaBroadcastOptions;
+        cursor: String?,
-import awais.instagrabber.repositories.requests.directmessages.BroadcastOptions;
+        seqId: Long,
-import awais.instagrabber.repositories.requests.directmessages.LinkBroadcastOptions;
+    ): Call<DirectInboxResponse?> {
-import awais.instagrabber.repositories.requests.directmessages.MediaShareBroadcastOptions;
+        val queryMap = mutableMapOf(
-import awais.instagrabber.repositories.requests.directmessages.PhotoBroadcastOptions;
+            "visual_message_return_type" to "unseen",
-import awais.instagrabber.repositories.requests.directmessages.ReactionBroadcastOptions;
+            "thread_message_limit" to 10.toString(),
-import awais.instagrabber.repositories.requests.directmessages.StoryReplyBroadcastOptions;
+            "persistentBadging" to true.toString(),
-import awais.instagrabber.repositories.requests.directmessages.TextBroadcastOptions;
+            "limit" to 10.toString(),
-import awais.instagrabber.repositories.requests.directmessages.ThreadIdOrUserIds;
+        )
-import awais.instagrabber.repositories.requests.directmessages.VideoBroadcastOptions;
+        if (!cursor.isNullOrBlank()) {
-import awais.instagrabber.repositories.requests.directmessages.VoiceBroadcastOptions;
+            queryMap["cursor"] = cursor
-import awais.instagrabber.repositories.responses.directmessages.DirectBadgeCount;
+            queryMap["direction"] = "older"
-import awais.instagrabber.repositories.responses.directmessages.DirectInboxResponse;
+        }
-import awais.instagrabber.repositories.responses.directmessages.DirectItem;
+        if (seqId != 0L) {
-import awais.instagrabber.repositories.responses.directmessages.DirectItemSeenResponse;
+            queryMap["seq_id"] = seqId.toString()
-import awais.instagrabber.repositories.responses.directmessages.DirectThread;
+        }
-import awais.instagrabber.repositories.responses.directmessages.DirectThreadBroadcastResponse;
+        return repository.fetchInbox(queryMap)
-import awais.instagrabber.repositories.responses.directmessages.DirectThreadDetailsChangeResponse;
+    }
-import awais.instagrabber.repositories.responses.directmessages.DirectThreadFeedResponse;
+    fun fetchThread(
-import awais.instagrabber.repositories.responses.directmessages.DirectThreadParticipantRequestsResponse;
+        threadId: String,
-import awais.instagrabber.repositories.responses.directmessages.RankedRecipientsResponse;
+        cursor: String?,
-import awais.instagrabber.repositories.responses.giphy.GiphyGif;
+    ): Call<DirectThreadFeedResponse?> {
-import awais.instagrabber.utils.TextUtils;
+        val queryMap = mutableMapOf(
-import awais.instagrabber.utils.Utils;
+            "visual_message_return_type" to "unseen",
-import retrofit2.Call;
+            "limit" to 20.toString(),
-
+            "direction" to "older",
-public class DirectMessagesService extends BaseService {
+        )
-    private static final String TAG = "DiscoverService";
+        if (!cursor.isNullOrBlank()) {
-
+            queryMap["cursor"] = cursor
-    private static DirectMessagesService instance;
+        }
-
+        return repository.fetchThread(threadId, queryMap)
-    private final DirectMessagesRepository repository;
+    }
-    private final String csrfToken;
+    fun fetchUnseenCount(): Call<DirectBadgeCount?> {
-    private final long userId;
+        return repository.fetchUnseenCount()
-    private final String deviceUuid;
+    }
-
+    fun broadcastText(
-    private DirectMessagesService(@NonNull final String csrfToken,
+        clientContext: String,
-                                  final long userId,
+        threadIdOrUserIds: ThreadIdOrUserIds,
-                                  @NonNull final String deviceUuid) {
+        text: String,
-        this.csrfToken = csrfToken;
+        repliedToItemId: String?,
-        this.userId = userId;
+        repliedToClientContext: String?,
-        this.deviceUuid = deviceUuid;
+    ): Call<DirectThreadBroadcastResponse?> {
-        repository = RetrofitFactory.getInstance()
+        val urls = extractUrls(text)
-                                    .getRetrofit()
+        if (urls.isNotEmpty()) {
-                                    .create(DirectMessagesRepository.class);
+            return broadcastLink(clientContext, threadIdOrUserIds, text, urls, repliedToItemId, repliedToClientContext)
-    }
+        }
-
+        val broadcastOptions = TextBroadcastOptions(clientContext, threadIdOrUserIds, text)
-    public String getCsrfToken() {
+        if (!repliedToItemId.isNullOrBlank() && !repliedToClientContext.isNullOrBlank()) {
-        return csrfToken;
+            broadcastOptions.repliedToItemId = repliedToItemId
-    }
+            broadcastOptions.repliedToClientContext = repliedToClientContext
-
+        }
-    public long getUserId() {
+        return broadcast(broadcastOptions)
-        return userId;
+    }
-    }
+    private fun broadcastLink(
-
+        clientContext: String,
-    public String getDeviceUuid() {
+        threadIdOrUserIds: ThreadIdOrUserIds,
-        return deviceUuid;
+        linkText: String,
-    }
+        urls: List<String>,
-
+        repliedToItemId: String?,
-    public static DirectMessagesService getInstance(@NonNull final String csrfToken,
+        repliedToClientContext: String?,
-                                                    final long userId,
+    ): Call<DirectThreadBroadcastResponse?> {
-                                                    @NonNull final String deviceUuid) {
+        val broadcastOptions = LinkBroadcastOptions(clientContext, threadIdOrUserIds, linkText, urls)
-        if (instance == null
+        if (!repliedToItemId.isNullOrBlank() && !repliedToClientContext.isNullOrBlank()) {
-                || !Objects.equals(instance.getCsrfToken(), csrfToken)
+            broadcastOptions.repliedToItemId = repliedToItemId
-                || !Objects.equals(instance.getUserId(), userId)
+            broadcastOptions.repliedToClientContext = repliedToClientContext
-                || !Objects.equals(instance.getDeviceUuid(), deviceUuid)) {
+        }
-            instance = new DirectMessagesService(csrfToken, userId, deviceUuid);
+        return broadcast(broadcastOptions)
-        }
+    }
-        return instance;
+    fun broadcastPhoto(
-    }
+        clientContext: String,
-
+        threadIdOrUserIds: ThreadIdOrUserIds,
-    public Call<DirectInboxResponse> fetchInbox(final String cursor,
+        uploadId: String,
-                                                final long seqId) {
+    ): Call<DirectThreadBroadcastResponse?> {
-        final ImmutableMap.Builder<String, Object> queryMapBuilder = ImmutableMap.<String, Object>builder()
+        return broadcast(PhotoBroadcastOptions(clientContext, threadIdOrUserIds, true, uploadId))
-                .put("visual_message_return_type", "unseen")
+    }
-                .put("thread_message_limit", 10)
+    fun broadcastVideo(
-                .put("persistentBadging", true)
+        clientContext: String,
-                .put("limit", 10);
+        threadIdOrUserIds: ThreadIdOrUserIds,
-        if (!TextUtils.isEmpty(cursor)) {
+        uploadId: String,
-            queryMapBuilder.put("cursor", cursor);
+        videoResult: String,
-            queryMapBuilder.put("direction", "older");
+        sampled: Boolean,
-        }
+    ): Call<DirectThreadBroadcastResponse?> {
-        if (seqId != 0) {
+        return broadcast(VideoBroadcastOptions(clientContext, threadIdOrUserIds, videoResult, uploadId, sampled))
-            queryMapBuilder.put("seq_id", seqId);
+    }
-        }
+    fun broadcastVoice(
-        return repository.fetchInbox(queryMapBuilder.build());
+        clientContext: String,
-    }
+        threadIdOrUserIds: ThreadIdOrUserIds,
-
+        uploadId: String,
-    public Call<DirectThreadFeedResponse> fetchThread(final String threadId,
+        waveform: List<Float>,
-                                                      final String cursor) {
+        samplingFreq: Int,
-        final ImmutableMap.Builder<String, Object> queryMapBuilder = ImmutableMap.<String, Object>builder()
+    ): Call<DirectThreadBroadcastResponse?> {
-                .put("visual_message_return_type", "unseen")
+        return broadcast(VoiceBroadcastOptions(clientContext, threadIdOrUserIds, uploadId, waveform, samplingFreq))
-                .put("limit", 20)
+    }
-                .put("direction", "older");
+    fun broadcastStoryReply(
-        if (!TextUtils.isEmpty(cursor)) {
+        threadIdOrUserIds: ThreadIdOrUserIds,
-            queryMapBuilder.put("cursor", cursor);
+        text: String,
-        }
+        mediaId: String,
-        return repository.fetchThread(threadId, queryMapBuilder.build());
+        reelId: String,
-    }
+    ): Call<DirectThreadBroadcastResponse?> {
-
+        return broadcast(StoryReplyBroadcastOptions(UUID.randomUUID().toString(), threadIdOrUserIds, text, mediaId, reelId))
-    public Call<DirectBadgeCount> fetchUnseenCount() {
+    }
-        return repository.fetchUnseenCount();
+    fun broadcastReaction(
-    }
+        clientContext: String,
-
+        threadIdOrUserIds: ThreadIdOrUserIds,
-    public Call<DirectThreadBroadcastResponse> broadcastText(@NonNull final String clientContext,
+        itemId: String,
-                                                             @NonNull final ThreadIdOrUserIds threadIdOrUserIds,
+        emoji: String?,
-                                                             @NonNull final String text,
+        delete: Boolean,
-                                                             @Nullable final String repliedToItemId,
+    ): Call<DirectThreadBroadcastResponse?> {
-                                                             @Nullable final String repliedToClientContext) {
+        return broadcast(ReactionBroadcastOptions(clientContext, threadIdOrUserIds, itemId, emoji, delete))
-        final List<String> urls = TextUtils.extractUrls(text);
+    }
-        if (!urls.isEmpty()) {
+    fun broadcastAnimatedMedia(
-            return broadcastLink(clientContext, threadIdOrUserIds, text, urls, repliedToItemId, repliedToClientContext);
+        clientContext: String,
-        }
+        threadIdOrUserIds: ThreadIdOrUserIds,
-        final TextBroadcastOptions broadcastOptions = new TextBroadcastOptions(clientContext, threadIdOrUserIds, text);
+        giphyGif: GiphyGif,
-        if (repliedToItemId != null && repliedToClientContext != null) {
+    ): Call<DirectThreadBroadcastResponse?> {
-            broadcastOptions.setRepliedToItemId(repliedToItemId);
+        return broadcast(AnimatedMediaBroadcastOptions(clientContext, threadIdOrUserIds, giphyGif))
-            broadcastOptions.setRepliedToClientContext(repliedToClientContext);
+    }
-        }
+    fun broadcastMediaShare(
-        return broadcast(broadcastOptions);
+        clientContext: String,
-    }
+        threadIdOrUserIds: ThreadIdOrUserIds,
-
+        mediaId: String,
-    public Call<DirectThreadBroadcastResponse> broadcastLink(@NonNull final String clientContext,
+    ): Call<DirectThreadBroadcastResponse?> {
-                                                             @NonNull final ThreadIdOrUserIds threadIdOrUserIds,
+        return broadcast(MediaShareBroadcastOptions(clientContext, threadIdOrUserIds, mediaId))
-                                                             @NonNull final String linkText,
+    }
-                                                             @NonNull final List<String> urls,
+    private fun broadcast(broadcastOptions: BroadcastOptions): Call<DirectThreadBroadcastResponse?> {
-                                                             @Nullable final String repliedToItemId,
+        require(!isEmpty(broadcastOptions.clientContext)) { "Broadcast requires a valid client context value" }
-                                                             @Nullable final String repliedToClientContext) {
+        val form = mutableMapOf<String, Any>()
-        final LinkBroadcastOptions broadcastOptions = new LinkBroadcastOptions(clientContext, threadIdOrUserIds, linkText, urls);
+        val threadId = broadcastOptions.threadId
-        if (repliedToItemId != null && repliedToClientContext != null) {
+        if (!threadId.isNullOrBlank()) {
-            broadcastOptions.setRepliedToItemId(repliedToItemId);
+            form["thread_id"] = threadId
-            broadcastOptions.setRepliedToClientContext(repliedToClientContext);
-        }
-        return broadcast(broadcastOptions);
-    }
-
-    public Call<DirectThreadBroadcastResponse> broadcastPhoto(@NonNull final String clientContext,
-                                                              @NonNull final ThreadIdOrUserIds threadIdOrUserIds,
-                                                              @NonNull final String uploadId) {
-        return broadcast(new PhotoBroadcastOptions(clientContext, threadIdOrUserIds, true, uploadId));
-    }
-
-    public Call<DirectThreadBroadcastResponse> broadcastVideo(@NonNull final String clientContext,
-                                                              @NonNull final ThreadIdOrUserIds threadIdOrUserIds,
-                                                              @NonNull final String uploadId,
-                                                              @NonNull final String videoResult,
-                                                              final boolean sampled) {
-        return broadcast(new VideoBroadcastOptions(clientContext, threadIdOrUserIds, videoResult, uploadId, sampled));
-    }
-
-    public Call<DirectThreadBroadcastResponse> broadcastVoice(@NonNull final String clientContext,
-                                                              @NonNull final ThreadIdOrUserIds threadIdOrUserIds,
-                                                              @NonNull final String uploadId,
-                                                              @NonNull final List<Float> waveform,
-                                                              final int samplingFreq) {
-        return broadcast(new VoiceBroadcastOptions(clientContext, threadIdOrUserIds, uploadId, waveform, samplingFreq));
-    }
-
-    public Call<DirectThreadBroadcastResponse> broadcastStoryReply(@NonNull final ThreadIdOrUserIds threadIdOrUserIds,
-                                                                   @NonNull final String text,
-                                                                   @NonNull final String mediaId,
-                                                                   @NonNull final String reelId) {
-        return broadcast(new StoryReplyBroadcastOptions(UUID.randomUUID().toString(), threadIdOrUserIds, text, mediaId, reelId));
-    }
-
-    public Call<DirectThreadBroadcastResponse> broadcastReaction(@NonNull final String clientContext,
-                                                                 @NonNull final ThreadIdOrUserIds threadIdOrUserIds,
-                                                                 @NonNull final String itemId,
-                                                                 @Nullable final String emoji,
-                                                                 final boolean delete) {
-        return broadcast(new ReactionBroadcastOptions(clientContext, threadIdOrUserIds, itemId, emoji, delete));
-    }
-
-    public Call<DirectThreadBroadcastResponse> broadcastAnimatedMedia(@NonNull final String clientContext,
-                                                                      @NonNull final ThreadIdOrUserIds threadIdOrUserIds,
-                                                                      @NonNull final GiphyGif giphyGif) {
-        return broadcast(new AnimatedMediaBroadcastOptions(clientContext, threadIdOrUserIds, giphyGif));
-    }
-
-    public Call<DirectThreadBroadcastResponse> broadcastMediaShare(@NonNull final String clientContext,
-                                                                   @NonNull final ThreadIdOrUserIds threadIdOrUserIds,
-                                                                   @NonNull final String mediaId) {
-        return broadcast(new MediaShareBroadcastOptions(clientContext, threadIdOrUserIds, mediaId));
-    }
-
-    private Call<DirectThreadBroadcastResponse> broadcast(@NonNull final BroadcastOptions broadcastOptions) {
-        if (TextUtils.isEmpty(broadcastOptions.getClientContext())) {
-            throw new IllegalArgumentException("Broadcast requires a valid client context value");
-        }
-        final Map<String, Object> form = new HashMap<>();
-        if (!TextUtils.isEmpty(broadcastOptions.getThreadId())) {
-            form.put("thread_id", broadcastOptions.getThreadId());
         } else {
-            form.put("recipient_users", new JSONArray(broadcastOptions.getUserIds()).toString());
+            val userIds = broadcastOptions.userIds
-        }
+            require(!userIds.isNullOrEmpty()) {
-        form.put("_csrftoken", csrfToken);
+                "Either provide a thread id or pass a list of user ids"
-        form.put("_uid", userId);
+            }
-        form.put("__uuid", deviceUuid);
+            form["recipient_users"] = JSONArray(userIds).toString()
-        form.put("client_context", broadcastOptions.getClientContext());
+        }
-        form.put("mutation_token", broadcastOptions.getClientContext());
+        form["_csrftoken"] = csrfToken
-        if (!TextUtils.isEmpty(broadcastOptions.getRepliedToItemId()) && !TextUtils.isEmpty(broadcastOptions.getRepliedToClientContext())) {
+        form["_uid"] = userId
-            form.put("replied_to_item_id", broadcastOptions.getRepliedToItemId());
+        form["__uuid"] = deviceUuid
-            form.put("replied_to_client_context", broadcastOptions.getRepliedToClientContext());
+        form["client_context"] = broadcastOptions.clientContext
-        }
+        form["mutation_token"] = broadcastOptions.clientContext
-        form.putAll(broadcastOptions.getFormMap());
+        val repliedToItemId = broadcastOptions.repliedToItemId
-        form.put("action", "send_item");
+        val repliedToClientContext = broadcastOptions.repliedToClientContext
-        final Map<String, String> signedForm = Utils.sign(form);
+        if (!repliedToItemId.isNullOrBlank() && !repliedToClientContext.isNullOrBlank()) {
-        return repository.broadcast(broadcastOptions.getItemType().getValue(), signedForm);
+            form["replied_to_item_id"] = repliedToItemId
-    }
+            form["replied_to_client_context"] = repliedToClientContext
-
+        }
-    public Call<DirectThreadDetailsChangeResponse> addUsers(final String threadId,
+        form.putAll(broadcastOptions.formMap)
-                                                            final Collection<Long> userIds) {
+        form["action"] = "send_item"
-        final ImmutableMap<String, String> form = ImmutableMap.of(
+        val signedForm = Utils.sign(form)
-                "_csrftoken", csrfToken,
+        return repository.broadcast(broadcastOptions.itemType.value, signedForm)
-                "_uuid", deviceUuid,
+    }
-                "user_ids", new JSONArray(userIds).toString()
+    fun addUsers(
-        );
+        threadId: String,
-        return repository.addUsers(threadId, form);
+        userIds: Collection<Long>,
-    }
+    ): Call<DirectThreadDetailsChangeResponse?> {
-
+        val form = mapOf(
-    public Call<String> removeUsers(final String threadId,
+            "_csrftoken" to csrfToken,
-                                    final Collection<Long> userIds) {
+            "_uuid" to deviceUuid,
-        final ImmutableMap<String, String> form = ImmutableMap.of(
+            "user_ids" to JSONArray(userIds).toString(),
-                "_csrftoken", csrfToken,
+        )
-                "_uuid", deviceUuid,
+        return repository.addUsers(threadId, form)
-                "user_ids", new JSONArray(userIds).toString()
+    }
-        );
+    fun removeUsers(
-        return repository.removeUsers(threadId, form);
+        threadId: String,
-    }
+        userIds: Collection<Long>,
-
+    ): Call<String?> {
-    public Call<DirectThreadDetailsChangeResponse> updateTitle(final String threadId,
+        val form = mapOf(
-                                                               final String title) {
+            "_csrftoken" to csrfToken,
-        final ImmutableMap<String, String> form = ImmutableMap.of(
+            "_uuid" to deviceUuid,
-                "_csrftoken", csrfToken,
+            "user_ids" to JSONArray(userIds).toString(),
-                "_uuid", deviceUuid,
+        )
-                "title", title
+        return repository.removeUsers(threadId, form)
-        );
+    }
-        return repository.updateTitle(threadId, form);
+    fun updateTitle(
-    }
+        threadId: String,
-
+        title: String,
-    public Call<String> addAdmins(final String threadId,
+    ): Call<DirectThreadDetailsChangeResponse?> {
-                                  final Collection<Long> userIds) {
+        val form = mapOf(
-        final ImmutableMap<String, String> form = ImmutableMap.of(
+            "_csrftoken" to csrfToken,
-                "_csrftoken", csrfToken,
+            "_uuid" to deviceUuid,
-                "_uuid", deviceUuid,
+            "title" to title,
-                "user_ids", new JSONArray(userIds).toString()
+        )
-        );
+        return repository.updateTitle(threadId, form)
-        return repository.addAdmins(threadId, form);
+    }
-    }
+    fun addAdmins(
-
+        threadId: String,
-    public Call<String> removeAdmins(final String threadId,
+        userIds: Collection<Long>,
-                                     final Collection<Long> userIds) {
+    ): Call<String?> {
-        final ImmutableMap<String, String> form = ImmutableMap.of(
+        val form = mapOf(
-                "_csrftoken", csrfToken,
+            "_csrftoken" to csrfToken,
-                "_uuid", deviceUuid,
+            "_uuid" to deviceUuid,
-                "user_ids", new JSONArray(userIds).toString()
+            "user_ids" to JSONArray(userIds).toString(),
-        );
+        )
-        return repository.removeAdmins(threadId, form);
+        return repository.addAdmins(threadId, form)
-    }
+    }
-
+    fun removeAdmins(
-    public Call<String> deleteItem(final String threadId,
+        threadId: String,
-                                   final String itemId) {
+        userIds: Collection<Long>,
-        final ImmutableMap<String, String> form = ImmutableMap.of(
+    ): Call<String?> {
-                "_csrftoken", csrfToken,
+        val form = mapOf(
-                "_uuid", deviceUuid
+            "_csrftoken" to csrfToken,
-        );
+            "_uuid" to deviceUuid,
-        return repository.deleteItem(threadId, itemId, form);
+            "user_ids" to JSONArray(userIds).toString(),
-    }
+        )
-
+        return repository.removeAdmins(threadId, form)
-    public Call<RankedRecipientsResponse> rankedRecipients(@Nullable final String mode,
+    }
-                                                           @Nullable final Boolean showThreads,
+    fun deleteItem(
-                                                           @Nullable final String query) {
+        threadId: String,
+        itemId: String,
+    ): Call<String?> {
+        val form = mapOf(
+            "_csrftoken" to csrfToken,
+            "_uuid" to deviceUuid,
+        )
+        return repository.deleteItem(threadId, itemId, form)
+    }
+
+    fun rankedRecipients(
+        mode: String?,
+        showThreads: Boolean?,
+        query: String?,
+    ): Call<RankedRecipientsResponse?> {
         // String correctedMode = mode;
         // if (TextUtils.isEmpty(mode) || (!mode.equals("raven") && !mode.equals("reshare"))) {
         //     correctedMode = "raven";
         // }
-        final ImmutableMap.Builder<String, String> builder = ImmutableMap.builder();
+        val queryMap = mutableMapOf<String, String>()
-        if (mode != null) {
+        if (!mode.isNullOrBlank()) {
-            builder.put("mode", mode);
+            queryMap["mode"] = mode
         }
-        if (query != null) {
+        if (!query.isNullOrBlank()) {
-            builder.put("query", query);
+            queryMap["query"] = query
         }
         if (showThreads != null) {
-            builder.put("showThreads", String.valueOf(showThreads));
+            queryMap["showThreads"] = showThreads.toString()
-        }
+        }
-        return repository.rankedRecipients(builder.build());
+        return repository.rankedRecipients(queryMap)
-    }
+    }
-
+    fun forward(
-    public Call<DirectThreadBroadcastResponse> forward(@NonNull final String toThreadId,
+        toThreadId: String,
-                                                       @NonNull final String itemType,
+        itemType: String,
-                                                       @NonNull final String fromThreadId,
+        fromThreadId: String,
-                                                       @NonNull final String itemId) {
+        itemId: String,
-        final ImmutableMap<String, String> form = ImmutableMap.of(
+    ): Call<DirectThreadBroadcastResponse?> {
-                "action", "forward_item",
+        val form = mapOf(
-                "thread_id", toThreadId,
+            "action" to "forward_item",
-                "item_type", itemType,
+            "thread_id" to toThreadId,
-                "forwarded_from_thread_id", fromThreadId,
+            "item_type" to itemType,
-                "forwarded_from_thread_item_id", itemId
+            "forwarded_from_thread_id" to fromThreadId,
-        );
+            "forwarded_from_thread_item_id" to itemId,
-        return repository.forward(form);
+        )
-    }
+        return repository.forward(form)
-
+    }
-    public Call<DirectThread> createThread(@NonNull final List<Long> userIds,
+    fun createThread(
-                                           @Nullable final String threadTitle) {
+        userIds: List<Long>,
-        final List<String> userIdStringList = userIds.stream()
+        threadTitle: String?,
-                                                     .filter(Objects::nonNull)
+    ): Call<DirectThread?> {
-                                                     .map(String::valueOf)
+        val userIdStringList = userIds.asSequence()
-                                                     .collect(Collectors.toList());
+            .filterNotNull()
-        final ImmutableMap.Builder<String, Object> formBuilder = ImmutableMap.<String, Object>builder()
+            .map { it.toString() }
-                .put("_csrftoken", csrfToken)
+        val form = mutableMapOf<String, Any>(
-                .put("_uuid", deviceUuid)
+            "_csrftoken" to csrfToken,
-                .put("_uid", userId)
+            "_uuid" to deviceUuid,
-                .put("recipient_users", new JSONArray(userIdStringList).toString());
+            "_uid" to userId,
-        if (threadTitle != null) {
+            "recipient_users" to JSONArray(userIdStringList).toString(),
-            formBuilder.put("thread_title", threadTitle);
+        )
-        }
+        if (!threadTitle.isNullOrBlank()) {
-        final Map<String, String> signedForm = Utils.sign(formBuilder.build());
+            form["thread_title"] = threadTitle
-        return repository.createThread(signedForm);
+        }
-    }
+        val signedForm = Utils.sign(form)
-
+        return repository.createThread(signedForm)
-    public Call<String> mute(@NonNull final String threadId) {
+    }
-        final ImmutableMap<String, String> form = ImmutableMap.of(
+    fun mute(threadId: String): Call<String?> {
-                "_csrftoken", csrfToken,
+        val form = mapOf(
-                "_uuid", deviceUuid
+            "_csrftoken" to csrfToken,
-        );
+            "_uuid" to deviceUuid
-        return repository.mute(threadId, form);
+        )
-    }
+        return repository.mute(threadId, form)
-
+    }
-    public Call<String> unmute(@NonNull final String threadId) {
+    fun unmute(threadId: String): Call<String?> {
-        final ImmutableMap<String, String> form = ImmutableMap.of(
+        val form = mapOf(
-                "_csrftoken", csrfToken,
+            "_csrftoken" to csrfToken,
-                "_uuid", deviceUuid
+            "_uuid" to deviceUuid,
-        );
+        )
-        return repository.unmute(threadId, form);
+        return repository.unmute(threadId, form)
-    }
+    }
-
+    fun muteMentions(threadId: String): Call<String?> {
-    public Call<String> muteMentions(@NonNull final String threadId) {
+        val form = mapOf(
-        final ImmutableMap<String, String> form = ImmutableMap.of(
+            "_csrftoken" to csrfToken,
-                "_csrftoken", csrfToken,
+            "_uuid" to deviceUuid,
-                "_uuid", deviceUuid
+        )
-        );
+        return repository.muteMentions(threadId, form)
-        return repository.muteMentions(threadId, form);
+    }
-    }
+    fun unmuteMentions(threadId: String): Call<String?> {
-
+        val form = mapOf(
-    public Call<String> unmuteMentions(@NonNull final String threadId) {
+            "_csrftoken" to csrfToken,
-        final ImmutableMap<String, String> form = ImmutableMap.of(
+            "_uuid" to deviceUuid,
-                "_csrftoken", csrfToken,
+        )
-                "_uuid", deviceUuid
+        return repository.unmuteMentions(threadId, form)
-        );
+    }
-        return repository.unmuteMentions(threadId, form);
+    fun participantRequests(
-    }
+        threadId: String,
-
+        pageSize: Int,
-    public Call<DirectThreadParticipantRequestsResponse> participantRequests(@NonNull final String threadId,
+        cursor: String?,
-                                                                             final int pageSize,
+    ): Call<DirectThreadParticipantRequestsResponse?> {
-                                                                             @Nullable final String cursor) {
+        return repository.participantRequests(threadId, pageSize, cursor)
-        return repository.participantRequests(threadId, pageSize, cursor);
+    }
-    }
+    fun approveParticipantRequests(
-
+        threadId: String,
-    public Call<DirectThreadDetailsChangeResponse> approveParticipantRequests(@NonNull final String threadId,
+        userIds: List<Long>,
-                                                                              @NonNull final List<Long> userIds) {
+    ): Call<DirectThreadDetailsChangeResponse?> {
-        final ImmutableMap<String, String> form = ImmutableMap.of(
+        val form = mapOf(
-                "_csrftoken", csrfToken,
+            "_csrftoken" to csrfToken,
-                "_uuid", deviceUuid,
+            "_uuid" to deviceUuid,
-                "user_ids", new JSONArray(userIds).toString()
+            "user_ids" to JSONArray(userIds).toString(),
-                // , "share_join_chat_story", String.valueOf(true)
+            // "share_join_chat_story" to String.valueOf(true)
-        );
+        )
-        return repository.approveParticipantRequests(threadId, form);
+        return repository.approveParticipantRequests(threadId, form)
-    }
+    }
-
+    fun declineParticipantRequests(
-    public Call<DirectThreadDetailsChangeResponse> declineParticipantRequests(@NonNull final String threadId,
+        threadId: String,
-                                                                              @NonNull final List<Long> userIds) {
+        userIds: List<Long>,
-        final ImmutableMap<String, String> form = ImmutableMap.of(
+    ): Call<DirectThreadDetailsChangeResponse?> {
-                "_csrftoken", csrfToken,
+        val form = mapOf(
-                "_uuid", deviceUuid,
+            "_csrftoken" to csrfToken,
-                "user_ids", new JSONArray(userIds).toString()
+            "_uuid" to deviceUuid,
-        );
+            "user_ids" to JSONArray(userIds).toString(),
-        return repository.declineParticipantRequests(threadId, form);
+        )
-    }
+        return repository.declineParticipantRequests(threadId, form)
-
+    }
-    public Call<DirectThreadDetailsChangeResponse> approvalRequired(@NonNull final String threadId) {
+    fun approvalRequired(threadId: String): Call<DirectThreadDetailsChangeResponse?> {
-        final ImmutableMap<String, String> form = ImmutableMap.of(
+        val form = mapOf(
-                "_csrftoken", csrfToken,
+            "_csrftoken" to csrfToken,
-                "_uuid", deviceUuid
+            "_uuid" to deviceUuid,
-        );
+        )
-        return repository.approvalRequired(threadId, form);
+        return repository.approvalRequired(threadId, form)
-    }
+    }
-
+    fun approvalNotRequired(threadId: String): Call<DirectThreadDetailsChangeResponse?> {
-    public Call<DirectThreadDetailsChangeResponse> approvalNotRequired(@NonNull final String threadId) {
+        val form = mapOf(
-        final ImmutableMap<String, String> form = ImmutableMap.of(
+            "_csrftoken" to csrfToken,
-                "_csrftoken", csrfToken,
+            "_uuid" to deviceUuid,
-                "_uuid", deviceUuid
+        )
-        );
+        return repository.approvalNotRequired(threadId, form)
-        return repository.approvalNotRequired(threadId, form);
+    }
-    }
+    fun leave(threadId: String): Call<DirectThreadDetailsChangeResponse?> {
-
+        val form = mapOf(
-    public Call<DirectThreadDetailsChangeResponse> leave(@NonNull final String threadId) {
+            "_csrftoken" to csrfToken,
-        final ImmutableMap<String, String> form = ImmutableMap.of(
+            "_uuid" to deviceUuid,
-                "_csrftoken", csrfToken,
+        )
-                "_uuid", deviceUuid
+        return repository.leave(threadId, form)
-        );
+    }
-        return repository.leave(threadId, form);
+    fun end(threadId: String): Call<DirectThreadDetailsChangeResponse?> {
-    }
+        val form = mapOf(
-
+            "_csrftoken" to csrfToken,
-    public Call<DirectThreadDetailsChangeResponse> end(@NonNull final String threadId) {
+            "_uuid" to deviceUuid,
-        final ImmutableMap<String, String> form = ImmutableMap.of(
+        )
-                "_csrftoken", csrfToken,
+        return repository.end(threadId, form)
-                "_uuid", deviceUuid
+    }
-        );
+    fun fetchPendingInbox(cursor: String?, seqId: Long): Call<DirectInboxResponse?> {
-        return repository.end(threadId, form);
+        val queryMap = mutableMapOf(
-    }
+            "visual_message_return_type" to "unseen",
-
+            "thread_message_limit" to 20.toString(),
-    public Call<DirectInboxResponse> fetchPendingInbox(final String cursor, final long seqId) {
+            "persistentBadging" to true.toString(),
-        final ImmutableMap.Builder<String, Object> queryMapBuilder = ImmutableMap.<String, Object>builder()
+            "limit" to 10.toString(),
-                .put("visual_message_return_type", "unseen")
+        )
-                .put("thread_message_limit", 20)
+        if (!cursor.isNullOrBlank()) {
-                .put("persistentBadging", true)
+            queryMap["cursor"] = cursor
-                .put("limit", 10);
+            queryMap["direction"] = "older"
-        if (!TextUtils.isEmpty(cursor)) {
+        }
-            queryMapBuilder.put("cursor", cursor);
+        if (seqId != 0L) {
-            queryMapBuilder.put("direction", "older");
+            queryMap["seq_id"] = seqId.toString()
-        }
+        }
-        if (seqId != 0) {
+        return repository.fetchPendingInbox(queryMap)
-            queryMapBuilder.put("seq_id", seqId);
+    }
-        }
+    fun approveRequest(threadId: String): Call<String?> {
-        return repository.fetchPendingInbox(queryMapBuilder.build());
+        val form = mapOf(
-    }
+            "_csrftoken" to csrfToken,
-
+            "_uuid" to deviceUuid,
-    public Call<String> approveRequest(@NonNull final String threadId) {
+        )
-        final ImmutableMap<String, String> form = ImmutableMap.of(
+        return repository.approveRequest(threadId, form)
-                "_csrftoken", csrfToken,
+    }
-                "_uuid", deviceUuid
+    fun declineRequest(threadId: String): Call<String?> {
-        );
+        val form = mapOf(
-        return repository.approveRequest(threadId, form);
+            "_csrftoken" to csrfToken,
-    }
+            "_uuid" to deviceUuid,
-
+        )
-    public Call<String> declineRequest(@NonNull final String threadId) {
+        return repository.declineRequest(threadId, form)
-        final ImmutableMap<String, String> form = ImmutableMap.of(
+    }
-                "_csrftoken", csrfToken,
+    fun markAsSeen(
-                "_uuid", deviceUuid
+        threadId: String,
-        );
+        directItem: DirectItem,
-        return repository.declineRequest(threadId, form);
+    ): Call<DirectItemSeenResponse?>? {
-    }
+        val itemId = directItem.itemId ?: return null
-
+        val form = mapOf(
-    @Nullable
+            "_csrftoken" to csrfToken,
-    public Call<DirectItemSeenResponse> markAsSeen(@NonNull final String threadId,
+            "_uuid" to deviceUuid,
-                                                   @NonNull final DirectItem directItem) {
+            "use_unified_inbox" to "true",
-        if (directItem.getItemId() == null) return null;
+            "action" to "mark_seen",
-        final ImmutableMap<String, String> form = ImmutableMap.<String, String>builder()
+            "thread_id" to threadId,
-                .put("_csrftoken", csrfToken)
+            "item_id" to itemId,
-                .put("_uuid", deviceUuid)
+        )
-                .put("use_unified_inbox", "true")
+        return repository.markItemSeen(threadId, itemId, form)
-                .put("action", "mark_seen")
+    }
-                .put("thread_id", threadId)
+    companion object {
-                .put("item_id", directItem.getItemId())
+        private lateinit var instance: DirectMessagesService
-                .build();
+        @JvmStatic
-        return repository.markItemSeen(threadId, directItem.getItemId(), form);
+        fun getInstance(
+            csrfToken: String,
+            userId: Long,
+            deviceUuid: String,
+        ): DirectMessagesService {
+            if (!this::instance.isInitialized
+                || instance.csrfToken != csrfToken
+                || instance.userId != userId
+                || instance.deviceUuid != deviceUuid
+            ) {
+                instance = DirectMessagesService(csrfToken, userId, deviceUuid)
+            }
+            return instance
+        }
     }
+
 }

app/src/main/java/awais/instagrabber/webservices/DiscoverService.java

@@ -22,7 +22,7 @@ public class DiscoverService extends BaseService {
     private static DiscoverService instance;
 
     private DiscoverService() {
-        repository = RetrofitFactory.getInstance()
+        repository = RetrofitFactory.INSTANCE
                                     .getRetrofit()
                                     .create(DiscoverRepository.class);
     }

app/src/main/java/awais/instagrabber/webservices/FeedService.java

@@ -31,7 +31,7 @@ public class FeedService extends BaseService {
     private static FeedService instance;
 
     private FeedService() {
-        repository = RetrofitFactory.getInstance()
+        repository = RetrofitFactory.INSTANCE
                                     .getRetrofit()
                                     .create(FeedRepository.class);
     }

app/src/main/java/awais/instagrabber/webservices/FriendshipService.java

@@ -41,7 +41,7 @@ public class FriendshipService extends BaseService {
         this.deviceUuid = deviceUuid;
         this.csrfToken = csrfToken;
         this.userId = userId;
-        repository = RetrofitFactory.getInstance()
+        repository = RetrofitFactory.INSTANCE
                                     .getRetrofit()
                                     .create(FriendshipRepository.class);
     }

app/src/main/java/awais/instagrabber/webservices/GifService.java

@@ -11,7 +11,7 @@ public class GifService extends BaseService {
     private static GifService instance;
 
     private GifService() {
-        repository = RetrofitFactory.getInstance()
+        repository = RetrofitFactory.INSTANCE
                                     .getRetrofit()
                                     .create(GifRepository.class);
     }

app/src/main/java/awais/instagrabber/webservices/GraphQLService.java

@@ -40,7 +40,7 @@ public class GraphQLService extends BaseService {
     private static GraphQLService instance;
 
     private GraphQLService() {
-        repository = RetrofitFactory.getInstance()
+        repository = RetrofitFactory.INSTANCE
                                     .getRetrofitWeb()
                                     .create(GraphQLRepository.class);
     }

app/src/main/java/awais/instagrabber/webservices/LocationService.java

@@ -22,7 +22,7 @@ public class LocationService extends BaseService {
     private static LocationService instance;
 
     private LocationService() {
-        repository = RetrofitFactory.getInstance()
+        repository = RetrofitFactory.INSTANCE
                                     .getRetrofit()
                                     .create(LocationRepository.class);
     }

app/src/main/java/awais/instagrabber/webservices/MediaService.java

@@ -54,7 +54,7 @@ public class MediaService extends BaseService {
         this.deviceUuid = deviceUuid;
         this.csrfToken = csrfToken;
         this.userId = userId;
-        repository = RetrofitFactory.getInstance()
+        repository = RetrofitFactory.INSTANCE
                                     .getRetrofit()
                                     .create(MediaRepository.class);
     }

app/src/main/java/awais/instagrabber/webservices/NewsService.java

@@ -31,7 +31,7 @@ public class NewsService extends BaseService {
     private static NewsService instance;
 
     private NewsService() {
-        repository = RetrofitFactory.getInstance()
+        repository = RetrofitFactory.INSTANCE
                                     .getRetrofit()
                                     .create(NewsRepository.class);
     }

app/src/main/java/awais/instagrabber/webservices/ProfileService.java

@@ -32,7 +32,7 @@ public class ProfileService extends BaseService {
     private static ProfileService instance;
 
     private ProfileService() {
-        repository = RetrofitFactory.getInstance()
+        repository = RetrofitFactory.INSTANCE
                                     .getRetrofit()
                                     .create(ProfileRepository.class);
     }

app/src/main/java/awais/instagrabber/webservices/RetrofitFactory.kt

@@ -1,98 +1,57 @@
-package awais.instagrabber.webservices;
+package awais.instagrabber.webservices
-
+import awais.instagrabber.BuildConfig
-import com.google.gson.FieldNamingPolicy;
+import awais.instagrabber.repositories.responses.Caption
-import com.google.gson.Gson;
+import awais.instagrabber.repositories.serializers.CaptionDeserializer
-import com.google.gson.GsonBuilder;
+import awais.instagrabber.utils.Utils
-
+import awais.instagrabber.webservices.interceptors.AddCookiesInterceptor
-import java.io.File;
+import awais.instagrabber.webservices.interceptors.IgErrorsInterceptor
-
+import com.google.gson.FieldNamingPolicy
-import awais.instagrabber.BuildConfig;
+import com.google.gson.GsonBuilder
-import awais.instagrabber.repositories.responses.Caption;
+import okhttp3.Cache
-import awais.instagrabber.repositories.serializers.CaptionDeserializer;
+import okhttp3.OkHttpClient
-import awais.instagrabber.utils.Utils;
+import retrofit2.Retrofit
-import awais.instagrabber.webservices.interceptors.AddCookiesInterceptor;
+import retrofit2.converter.gson.GsonConverterFactory
-import awais.instagrabber.webservices.interceptors.IgErrorsInterceptor;
+import retrofit2.converter.scalars.ScalarsConverterFactory
-import okhttp3.Cache;
+import java.io.File
-import okhttp3.OkHttpClient;
+object RetrofitFactory {
-import retrofit2.Retrofit;
+    private const val cacheSize: Long = 10 * 1024 * 1024 // 10 MB
-import retrofit2.converter.gson.GsonConverterFactory;
+    private val cache = Cache(File(Utils.cacheDir), cacheSize)
-import retrofit2.converter.scalars.ScalarsConverterFactory;
+    private val igErrorsInterceptor: IgErrorsInterceptor by lazy { IgErrorsInterceptor() }
-
+    private val retrofitBuilder: Retrofit.Builder by lazy {
-public final class RetrofitFactory {
+        val clientBuilder = OkHttpClient.Builder().apply {
-    private static final Object LOCK = new Object();
+            followRedirects(false)
-
+            followSslRedirects(false)
-    private static RetrofitFactory instance;
+            cache(cache)
-
+            addInterceptor(AddCookiesInterceptor())
-    private final int cacheSize = 10 * 1024 * 1024; // 10 MB
+            addInterceptor(igErrorsInterceptor)
-    private final Cache cache = new Cache(new File(Utils.cacheDir), cacheSize);
-
-    private IgErrorsInterceptor igErrorsInterceptor;
-    private Retrofit.Builder builder;
-    private Retrofit retrofit;
-    private Retrofit retrofitWeb;
-
-    public static RetrofitFactory getInstance() {
-        if (instance == null) {
-            synchronized (LOCK) {
-                if (instance == null) {
-                    instance = new RetrofitFactory();
-                }
-            }
-        }
-        return instance;
-    }
-
-    private Retrofit.Builder getRetrofitBuilder() {
-        if (builder == null) {
-            igErrorsInterceptor = new IgErrorsInterceptor();
-            final OkHttpClient.Builder clientBuilder = new OkHttpClient.Builder()
-                    .followRedirects(false)
-                    .followSslRedirects(false)
-                    .cache(cache);
             if (BuildConfig.DEBUG) {
-                // clientBuilder.addInterceptor(new LoggingInterceptor());
+                // addInterceptor(new LoggingInterceptor());
             }
-            clientBuilder.addInterceptor(new AddCookiesInterceptor())
-                         .addInterceptor(igErrorsInterceptor);
-            final Gson gson = new GsonBuilder()
-                    .setFieldNamingPolicy(FieldNamingPolicy.LOWER_CASE_WITH_UNDERSCORES)
-                    .registerTypeAdapter(Caption.class, new CaptionDeserializer())
-                    .setLenient()
-                    .create();
-            builder = new Retrofit.Builder()
-                    .addConverterFactory(ScalarsConverterFactory.create())
-                    .addConverterFactory(GsonConverterFactory.create(gson))
-                    .client(clientBuilder.build());
         }
-        return builder;
+        val gson = GsonBuilder().apply {
+            setFieldNamingPolicy(FieldNamingPolicy.LOWER_CASE_WITH_UNDERSCORES)
+            registerTypeAdapter(Caption::class.java, CaptionDeserializer())
+            setLenient()
+        }.create()
+        Retrofit.Builder().apply {
+            addConverterFactory(ScalarsConverterFactory.create())
+            addConverterFactory(GsonConverterFactory.create(gson))
+            client(clientBuilder.build())
+        }
     }
 
-    public Retrofit getRetrofit() {
+    val retrofit: Retrofit by lazy {
-        if (retrofit == null) {
+        retrofitBuilder
-            retrofit = getRetrofitBuilder()
             .baseUrl("https://i.instagram.com")
-                    .build();
+            .build()
-        }
-        return retrofit;
     }
 
-    public Retrofit getRetrofitWeb() {
+    val retrofitWeb: Retrofit by lazy {
-        if (retrofitWeb == null) {
+        retrofitBuilder
-            retrofitWeb = getRetrofitBuilder()
             .baseUrl("https://www.instagram.com")
-                    .build();
+            .build()
-        }
-        return retrofitWeb;
-    }
-
-    public void destroy() {
-        if (igErrorsInterceptor != null) {
-            igErrorsInterceptor.destroy();
-        }
-        igErrorsInterceptor = null;
-        retrofit = null;
-        retrofitWeb = null;
-        builder = null;
-        instance = null;
     }
 }

app/src/main/java/awais/instagrabber/webservices/SearchService.java

@@ -14,7 +14,7 @@ public class SearchService extends BaseService {
     private static SearchService instance;
 
     private SearchService() {
-        repository = RetrofitFactory.getInstance()
+        repository = RetrofitFactory.INSTANCE
                                     .getRetrofitWeb()
                                     .create(SearchRepository.class);
     }

app/src/main/java/awais/instagrabber/webservices/StoriesService.java

@@ -49,7 +49,7 @@ public class StoriesService extends BaseService {
         this.csrfToken = csrfToken;
         this.userId = userId;
         this.deviceUuid = deviceUuid;
-        repository = RetrofitFactory.getInstance()
+        repository = RetrofitFactory.INSTANCE
                                     .getRetrofit()
                                     .create(StoriesRepository.class);
     }

app/src/main/java/awais/instagrabber/webservices/TagsService.java

@@ -31,7 +31,7 @@ public class TagsService extends BaseService {
     private final TagsRepository repository;
 
     private TagsService() {
-        repository = RetrofitFactory.getInstance()
+        repository = RetrofitFactory.INSTANCE
                                     .getRetrofit()
                                     .create(TagsRepository.class);
     }

app/src/main/java/awais/instagrabber/webservices/UserService.java

@@ -21,7 +21,7 @@ public class UserService extends BaseService {
     private static UserService instance;
 
     private UserService() {
-        repository = RetrofitFactory.getInstance()
+        repository = RetrofitFactory.INSTANCE
                                     .getRetrofit()
                                     .create(UserRepository.class);
     }