// allgram Blogs Kotlin Android Integration Example
package com.allgram.blogs
import android.util.Log
import androidx.compose.runtime.*
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
import okhttp3.*
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.RequestBody.Companion.toRequestBody
import org.json.JSONObject
import java.security.MessageDigest
import javax.crypto.Cipher
import javax.crypto.spec.GCMParameterSpec
import javax.crypto.spec.SecretKeySpec
// MARK: - Data Models
data class Blog(
val blogId: String,
val blogName: String,
val blogDescription: String,
val isPublic: Boolean,
val isPaid: Boolean,
val monthlyPrice: Double?,
val participants: List<String>,
val creationDatetime: Long,
val momentsCount: Int,
val subscribersCount: Int
)
data class Post(
val postId: String,
val blogId: String,
val author: String,
val content: PostContent,
val creationDatetime: Long,
val isMoment: Boolean = false,
val expirationDate: Long? = null,
val viewsCount: Int = 0,
val reactionsCount: Int = 0,
val commentsCount: Int = 0
)
data class PostContent(
val text: String? = null,
val media: List<String>? = null,
val tags: List<String>? = null
)
// MARK: - Blog Service
class allgramBlogsService(
private val apiKey: String,
private val baseUrl: String = "https://api.allgram.best"
) {
private val client = OkHttpClient.Builder()
.connectTimeout(30, TimeUnit.SECONDS)
.readTimeout(30, TimeUnit.SECONDS)
.writeTimeout(30, TimeUnit.SECONDS)
.build()
private var webSocket: WebSocket? = null
private val postCallbacks = mutableListOf<(Post) -> Unit>()
private val momentCallbacks = mutableListOf<(Post) -> Unit>()
// MARK: - WebSocket Management
fun connectWebSocket() {
val request = Request.Builder()
.url("wss://api.allgram.best/ws/blogs/")
.build()
webSocket = client.newWebSocket(request, object : WebSocketListener() {
override fun onOpen(webSocket: WebSocket, response: Response) {
Log.d("allgramBlogs", "✅ WebSocket connected")
// Authenticate
sendWebSocketMessage(JSONObject().apply {
put("type", "auth")
put("api_key", apiKey)
}.toString())
}
override fun onMessage(webSocket: WebSocket, text: String) {
try {
val json = JSONObject(text)
handleWebSocketMessage(json)
} catch (e: Exception) {
Log.e("allgramBlogs", "Failed to parse WebSocket message", e)
}
}
override fun onFailure(webSocket: WebSocket, t: Throwable, response: Response?) {
Log.e("allgramBlogs", "WebSocket failure", t)
// Attempt reconnection
CoroutineScope(Dispatchers.IO).launch {
delay(5000)
connectWebSocket()
}
}
})
}
// MARK: - Blog Management
suspend fun createBlog(
name: String,
description: String,
isPublic: Boolean = true,
isPaid: Boolean = false,
monthlyPrice: Double? = null
): Result<Blog> = withContext(Dispatchers.IO) {
try {
val requestBody = JSONObject().apply {
put("blog_name", name)
put("blog_description", description)
put("is_public", isPublic)
put("is_paid", isPaid)
if (monthlyPrice != null) {
put("monthly_price", monthlyPrice)
}
}.toString()
val request = Request.Builder()
.url("$baseUrl/blogs/create")
.post(requestBody.toRequestBody("application/json".toMediaType()))
.addHeader("Authorization", "Bearer $apiKey")
.build()
val response = client.newCall(request).execute()
if (response.isSuccessful) {
val responseBody = response.body?.string()
val blogJson = JSONObject(responseBody ?: "")
val blog = Blog(
blogId = blogJson.getString("blog_id"),
blogName = blogJson.getString("blog_name"),
blogDescription = blogJson.getString("blog_description"),
isPublic = blogJson.optBoolean("is_public", true),
isPaid = blogJson.optBoolean("is_paid", false),
monthlyPrice = if (blogJson.has("monthly_price")) blogJson.optDouble("monthly_price") else null,
participants = emptyList(),
creationDatetime = blogJson.optLong("creation_datetime", System.currentTimeMillis() / 1000),
momentsCount = blogJson.optInt("moments_count", 0),
subscribersCount = blogJson.optInt("subscribers_count", 0)
)
Log.d("allgramBlogs", "✅ Blog created: ${blog.blogName}")
Result.success(blog)
} else {
Log.e("allgramBlogs", "Failed to create blog: ${response.code}")
Result.failure(Exception("Server error: ${response.code}"))
}
} catch (e: Exception) {
Log.e("allgramBlogs", "Exception creating blog", e)
Result.failure(e)
}
}
// MARK: - Post Management
suspend fun createPost(
blogId: String,
content: String,
isMoment: Boolean = false,
expirationDate: Long? = null
): Result<Unit> = withContext(Dispatchers.IO) {
try {
val postData = JSONObject().apply {
put("blog", blogId)
put("content", content)
put("is_moment", isMoment)
if (expirationDate != null) {
put("expiration_date", expirationDate)
}
}
val request = Request.Builder()
.url("$baseUrl/posts/create")
.post(postData.toString().toRequestBody("application/json".toMediaType()))
.addHeader("Authorization", "Bearer $apiKey")
.build()
val response = client.newCall(request).execute()
if (response.isSuccessful) {
Log.d("allgramBlogs", "✅ Post created successfully")
Result.success(Unit)
} else {
Log.e("allgramBlogs", "Failed to create post: ${response.code}")
Result.failure(Exception("Server error: ${response.code}"))
}
} catch (e: Exception) {
Log.e("allgramBlogs", "Exception creating post", e)
Result.failure(e)
}
}
// MARK: - Moment Creation
suspend fun createMoment(
blogId: String,
content: String,
hoursToExpire: Int = 24
): Result<Unit> = withContext(Dispatchers.IO) {
val expirationDate = System.currentTimeMillis() / 1000 + (hoursToExpire * 3600)
return createPost(blogId, content, true, expirationDate)
}
// MARK: - WebSocket Communication
private fun sendWebSocketMessage(message: String) {
webSocket?.send(message) ?: run {
Log.w("allgramBlogs", "WebSocket not connected")
}
}
private fun handleWebSocketMessage(json: JSONObject) {
when {
json.has("new_posts") -> {
val newPosts = json.getInt("new_posts")
Log.d("allgramBlogs", "📝 New posts available: $newPosts")
handleNewPosts()
}
json.has("new_moments") -> {
val newMoments = json.getInt("new_moments")
Log.d("allgramBlogs", "⚡ New moments available: $newMoments")
handleNewMoments()
}
}
}
private fun handleNewPosts() {
Log.d("allgramBlogs", "📝 New posts available")
// Notify callbacks
postCallbacks.forEach { callback ->
// This would typically involve fetching new posts
}
}
private fun handleNewMoments() {
Log.d("allgramBlogs", "⚡ New moments available")
// Notify callbacks
momentCallbacks.forEach { callback ->
// This would typically involve fetching new moments
}
}
// MARK: - Callbacks
fun addPostCallback(callback: (Post) -> Unit) {
postCallbacks.add(callback)
}
fun addMomentCallback(callback: (Post) -> Unit) {
momentCallbacks.add(callback)
}
fun removePostCallback(callback: (Post) -> Unit) {
postCallbacks.remove(callback)
}
fun removeMomentCallback(callback: (Post) -> Unit) {
momentCallbacks.remove(callback)
}
// MARK: - Cleanup
fun disconnect() {
webSocket?.close(1000, "Disconnecting")
webSocket = null
}
}
// MARK: - ViewModel
class BlogsViewModel(
private val blogService: allgramBlogsService
) : ViewModel() {
private val _blogs = MutableStateFlow<List<Blog>>(emptyList())
val blogs: StateFlow<List<Blog>> = _blogs.asStateFlow()
private val _currentBlog = MutableStateFlow<Blog?>(null)
val currentBlog: StateFlow<Blog?> = _currentBlog.asStateFlow()
private val _posts = MutableStateFlow<List<Post>>(emptyList())
val posts: StateFlow<List<Post>> = _posts.asStateFlow()
private val _isLoading = MutableStateFlow(false)
val isLoading: StateFlow<Boolean> = _isLoading.asStateFlow()
init {
setupBlogService()
}
private fun setupBlogService() {
blogService.addPostCallback { post ->
if (post.blogId == _currentBlog.value?.blogId) {
_posts.value = _posts.value + post
}
}
blogService.addMomentCallback { moment ->
// Handle new moments
Log.d("BlogsViewModel", "New moment received: ${moment.postId}")
}
}
fun createBlog(name: String, description: String, isPublic: Boolean = true, isPaid: Boolean = false) {
viewModelScope.launch {
_isLoading.value = true
try {
val result = blogService.createBlog(name, description, isPublic, isPaid)
result.onSuccess { blog ->
_blogs.value = _blogs.value + blog
}.onFailure { error ->
Log.e("BlogsViewModel", "Failed to create blog", error)
}
} finally {
_isLoading.value = false
}
}
}
fun createPost(content: String) {
val currentBlog = _currentBlog.value ?: return
viewModelScope.launch {
val result = blogService.createPost(currentBlog.blogId, content)
result.onFailure { error ->
Log.e("BlogsViewModel", "Failed to create post", error)
}
}
}
fun createMoment(content: String, hoursToExpire: Int = 24) {
val currentBlog = _currentBlog.value ?: return
viewModelScope.launch {
val result = blogService.createMoment(currentBlog.blogId, content, hoursToExpire)
result.onFailure { error ->
Log.e("BlogsViewModel", "Failed to create moment", error)
}
}
}
fun selectBlog(blog: Blog) {
_currentBlog.value = blog
// Load blog posts
loadBlogPosts(blog.blogId)
}
private fun loadBlogPosts(blogId: String) {
// Implementation for loading blog posts
// This would typically involve API calls to fetch post history
}
override fun onCleared() {
super.onCleared()
blogService.disconnect()
}
}
// MARK: - Compose UI
@Composable
fun BlogListScreen(
viewModel: BlogsViewModel = viewModel { BlogsViewModel(allgramBlogsService("your-api-key")) }
) {
val blogs by viewModel.blogs.collectAsState()
val isLoading by viewModel.isLoading.collectAsState()
LazyColumn {
items(blogs) { blog ->
BlogItem(
blog = blog,
onClick = { viewModel.selectBlog(blog) }
)
}
}
if (isLoading) {
CircularProgressIndicator()
}
}
@Composable
fun BlogItem(
blog: Blog,
onClick: () -> Unit
) {
Card(
modifier = Modifier
.fillMaxWidth()
.padding(8.dp)
.clickable { onClick() },
elevation = CardDefaults.cardElevation(defaultElevation = 4.dp)
) {
Column(
modifier = Modifier.padding(16.dp)
) {
Row(
modifier = Modifier.fillMaxWidth(),
horizontalArrangement = Arrangement.SpaceBetween,
verticalAlignment = Alignment.CenterVertically
) {
Text(
text = blog.blogName,
style = MaterialTheme.typography.h6
)
if (blog.isPaid) {
Icon(
imageVector = Icons.Default.AttachMoney,
contentDescription = "Paid Blog",
tint = Color.Green
)
}
}
Text(
text = blog.blogDescription,
style = MaterialTheme.typography.body2,
color = MaterialTheme.colors.onSurface.copy(alpha = 0.6f)
)
HStack {
Text(
text = "${blog.subscribersCount} subscribers",
style = MaterialTheme.typography.caption,
color = MaterialTheme.colors.onSurface.copy(alpha = 0.6f)
)
Spacer()
Text(
text = "${blog.momentsCount} moments",
style = MaterialTheme.typography.caption,
color = MaterialTheme.colors.onSurface.copy(alpha = 0.6f)
)
}
}
}
}
