Mobile App Integration Guide

POST /api/projects/{projectId}/feedback

{
  "message": "User's feedback message",
  "context": {
    "url": "myapp://checkout",
    "userAgent": "MyApp/2.1.0 (iOS 17.2; iPhone 15 Pro)",
    "timestamp": "2025-01-15T10:30:00.000Z",
    "screen": {
      "width": 1179,
      "height": 2556
    },
    "appVersion": "2.1.0",
    "platform": "iOS",
    "osVersion": "17.2",
    "deviceModel": "iPhone 15 Pro",
    "userId": "user_123",
    "screenName": "CheckoutScreen"
  }
}

{
  "data": {
    "id": "feedback_abc123",
    "message": "User's feedback message",
    "context": { ... },
    "status": "NEW",
    "createdAt": "2025-01-15T10:30:00.000Z"
  }
}

{
  "error": "Error message describing the issue"
}

import Foundation
 
struct FeedbackService {
    private let projectId: String
    private let apiKey: String
    private let baseURL = "https://miniback.io"
    
    init(projectId: String, apiKey: String) {
        self.projectId = projectId
        self.apiKey = apiKey
    }
    
    func submitFeedback(
        message: String,
        context: [String: Any]? = nil
    ) async throws -> String {
        let url = URL(string: "\(baseURL)/api/projects/\(projectId)/feedback")!
        
        var request = URLRequest(url: url)
        request.httpMethod = "POST"
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
        request.setValue(apiKey, forHTTPHeaderField: "x-api-key")
        
        var body: [String: Any] = ["message": message]
        if let context = context {
            body["context"] = context
        }
        
        request.httpBody = try JSONSerialization.data(withJSONObject: body)
        
        let (data, response) = try await URLSession.shared.data(for: request)
        
        guard let httpResponse = response as? HTTPURLResponse,
              (200...299).contains(httpResponse.statusCode) else {
            throw FeedbackError.submissionFailed
        }
        
        let json = try JSONSerialization.jsonObject(with: data) as? [String: Any]
        let feedbackData = json?["data"] as? [String: Any]
        return feedbackData?["id"] as? String ?? ""
    }
    
    func buildContext(screenName: String? = nil) -> [String: Any] {
        let appVersion = Bundle.main.infoDictionary?["CFBundleShortVersionString"] as? String ?? "unknown"
        let osVersion = UIDevice.current.systemVersion
        let deviceModel = UIDevice.current.model
        
        return [
            // Standard fields (widget-compatible)
            "url": screenName ?? "unknown",
            "userAgent": "MyApp/\(appVersion) (iOS \(osVersion); \(deviceModel))",
            "timestamp": ISO8601DateFormatter().string(from: Date()),
            "screen": [
                "width": Int(UIScreen.main.bounds.width * UIScreen.main.scale),
                "height": Int(UIScreen.main.bounds.height * UIScreen.main.scale)
            ],
            // Mobile-specific fields
            "platform": "iOS",
            "appVersion": appVersion,
            "osVersion": osVersion,
            "deviceModel": deviceModel,
            "screenName": screenName ?? "unknown"
        ]
    }
}
 
enum FeedbackError: Error {
    case submissionFailed
}
 
// Usage
let feedbackService = FeedbackService(
    projectId: "your_project_id",
    apiKey: "mbk_your_api_key"
)
 
Task {
    do {
        let feedbackId = try await feedbackService.submitFeedback(
            message: "The checkout button is hard to find",
            context: feedbackService.buildContext(screenName: "CheckoutScreen")
        )
        print("Feedback submitted: \(feedbackId)")
    } catch {
        print("Failed to submit feedback: \(error)")
    }
}

import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import org.json.JSONObject
import java.net.HttpURLConnection
import java.net.URL
 
class FeedbackService(
    private val projectId: String,
    private val apiKey: String
) {
    private val baseUrl = "https://miniback.io"
    
    suspend fun submitFeedback(
        message: String,
        context: Map<String, Any>? = null
    ): Result<String> = withContext(Dispatchers.IO) {
        try {
            val url = URL("$baseUrl/api/projects/$projectId/feedback")
            val connection = url.openConnection() as HttpURLConnection
            
            connection.apply {
                requestMethod = "POST"
                setRequestProperty("Content-Type", "application/json")
                setRequestProperty("x-api-key", apiKey)
                doOutput = true
            }
            
            val body = JSONObject().apply {
                put("message", message)
                context?.let { put("context", JSONObject(it)) }
            }
            
            connection.outputStream.use { 
                it.write(body.toString().toByteArray()) 
            }
            
            if (connection.responseCode in 200..299) {
                val response = connection.inputStream.bufferedReader().readText()
                val json = JSONObject(response)
                val feedbackId = json.getJSONObject("data").getString("id")
                Result.success(feedbackId)
            } else {
                Result.failure(Exception("Submission failed: ${connection.responseCode}"))
            }
        } catch (e: Exception) {
            Result.failure(e)
        }
    }
    
    fun buildContext(context: android.content.Context, screenName: String? = null): Map<String, Any> {
        val appVersion = context.packageManager
            .getPackageInfo(context.packageName, 0).versionName ?: "unknown"
        val osVersion = android.os.Build.VERSION.RELEASE
        val deviceModel = android.os.Build.MODEL
        val displayMetrics = context.resources.displayMetrics
        
        return mapOf(
            // Standard fields (widget-compatible)
            "url" to (screenName ?: "unknown"),
            "userAgent" to "MyApp/$appVersion (Android $osVersion; $deviceModel)",
            "timestamp" to java.time.Instant.now().toString(),
            "screen" to mapOf(
                "width" to displayMetrics.widthPixels,
                "height" to displayMetrics.heightPixels
            ),
            // Mobile-specific fields
            "platform" to "Android",
            "appVersion" to appVersion,
            "osVersion" to osVersion,
            "deviceModel" to deviceModel,
            "screenName" to (screenName ?: "unknown")
        )
    }
}
 
// Usage
val feedbackService = FeedbackService(
    projectId = "your_project_id",
    apiKey = "mbk_your_api_key"
)
 
lifecycleScope.launch {
    feedbackService.submitFeedback(
        message = "App crashes when I tap the menu",
        context = feedbackService.buildContext(applicationContext, "MenuScreen")
    ).onSuccess { feedbackId ->
        Log.d("Feedback", "Submitted: $feedbackId")
    }.onFailure { error ->
        Log.e("Feedback", "Failed: ${error.message}")
    }
}

interface FeedbackContext {
  // Standard fields (widget-compatible)
  url?: string;
  userAgent?: string;
  timestamp?: string;
  screen?: { width: number; height: number };
  // Mobile-specific fields
  platform?: string;
  appVersion?: string;
  osVersion?: string;
  deviceModel?: string;
  screenName?: string;
  userId?: string;
  [key: string]: any;
}
 
interface FeedbackResponse {
  data: {
    id: string;
    message: string;
    status: string;
    createdAt: string;
  };
}
 
class FeedbackService {
  private projectId: string;
  private apiKey: string;
  private baseUrl = 'https://miniback.io';
 
  constructor(projectId: string, apiKey: string) {
    this.projectId = projectId;
    this.apiKey = apiKey;
  }
 
  async submitFeedback(
    message: string,
    context?: FeedbackContext
  ): Promise<string> {
    const response = await fetch(
      `${this.baseUrl}/api/projects/${this.projectId}/feedback`,
      {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          'x-api-key': this.apiKey,
        },
        body: JSON.stringify({ message, context }),
      }
    );
 
    if (!response.ok) {
      const error = await response.json();
      throw new Error(error.error || 'Failed to submit feedback');
    }
 
    const data: FeedbackResponse = await response.json();
    return data.data.id;
  }
 
  buildContext(screenName?: string): FeedbackContext {
    const { Platform, Dimensions } = require('react-native');
    const DeviceInfo = require('react-native-device-info');
    
    const appVersion = DeviceInfo.getVersion();
    const osVersion = Platform.Version.toString();
    const deviceModel = DeviceInfo.getModel();
    const { width, height } = Dimensions.get('screen');
 
    return {
      // Standard fields (widget-compatible)
      url: screenName || 'unknown',
      userAgent: `MyApp/${appVersion} (${Platform.OS} ${osVersion}; ${deviceModel})`,
      timestamp: new Date().toISOString(),
      screen: { width, height },
      // Mobile-specific fields
      platform: Platform.OS,
      appVersion,
      osVersion,
      deviceModel,
      screenName: screenName || 'unknown',
    };
  }
}
 
// Usage
const feedbackService = new FeedbackService(
  'your_project_id',
  'mbk_your_api_key'
);
 
async function sendFeedback(userMessage: string, screenName: string) {
  try {
    const feedbackId = await feedbackService.submitFeedback(
      userMessage,
      feedbackService.buildContext(screenName)
    );
    console.log('Feedback submitted:', feedbackId);
  } catch (error) {
    console.error('Failed to submit feedback:', error);
  }
}
 
// Example: sendFeedback("Bug on checkout", "CheckoutScreen");

import 'dart:convert';
import 'dart:io';
import 'package:flutter/widgets.dart';
import 'package:http/http.dart' as http;
import 'package:device_info_plus/device_info_plus.dart';
import 'package:package_info_plus/package_info_plus.dart';
 
class FeedbackService {
  final String projectId;
  final String apiKey;
  final String baseUrl = 'https://miniback.io';
 
  FeedbackService({
    required this.projectId,
    required this.apiKey,
  });
 
  Future<String> submitFeedback(
    String message, {
    Map<String, dynamic>? context,
  }) async {
    final url = Uri.parse('$baseUrl/api/projects/$projectId/feedback');
 
    final response = await http.post(
      url,
      headers: {
        'Content-Type': 'application/json',
        'x-api-key': apiKey,
      },
      body: jsonEncode({
        'message': message,
        if (context != null) 'context': context,
      }),
    );
 
    if (response.statusCode >= 200 && response.statusCode < 300) {
      final data = jsonDecode(response.body);
      return data['data']['id'];
    } else {
      final error = jsonDecode(response.body);
      throw Exception(error['error'] ?? 'Failed to submit feedback');
    }
  }
 
  Future<Map<String, dynamic>> buildContext({String? screenName}) async {
    final deviceInfo = DeviceInfoPlugin();
    final packageInfo = await PackageInfo.fromPlatform();
    
    String platform = 'unknown';
    String osVersion = 'unknown';
    String deviceModel = 'unknown';
 
    if (Platform.isAndroid) {
      final androidInfo = await deviceInfo.androidInfo;
      platform = 'Android';
      osVersion = androidInfo.version.release;
      deviceModel = androidInfo.model;
    } else if (Platform.isIOS) {
      final iosInfo = await deviceInfo.iosInfo;
      platform = 'iOS';
      osVersion = iosInfo.systemVersion;
      deviceModel = iosInfo.model;
    }
    
    // Get screen dimensions
    final window = WidgetsBinding.instance.window;
    final screenWidth = window.physicalSize.width.toInt();
    final screenHeight = window.physicalSize.height.toInt();
 
    return {
      // Standard fields (widget-compatible)
      'url': screenName ?? 'unknown',
      'userAgent': '${packageInfo.appName}/${packageInfo.version} ($platform $osVersion; $deviceModel)',
      'timestamp': DateTime.now().toIso8601String(),
      'screen': {
        'width': screenWidth,
        'height': screenHeight,
      },
      // Mobile-specific fields
      'platform': platform,
      'appVersion': packageInfo.version,
      'osVersion': osVersion,
      'deviceModel': deviceModel,
      'screenName': screenName ?? 'unknown',
      'buildNumber': packageInfo.buildNumber,
    };
  }
}
 
// Usage
final feedbackService = FeedbackService(
  projectId: 'your_project_id',
  apiKey: 'mbk_your_api_key',
);
 
Future<void> sendFeedback(String userMessage, String screenName) async {
  try {
    final context = await feedbackService.buildContext(screenName: screenName);
    final feedbackId = await feedbackService.submitFeedback(
      userMessage,
      context: context,
    );
    print('Feedback submitted: $feedbackId');
  } catch (e) {
    print('Failed to submit feedback: $e');
  }
}
 
// Example: sendFeedback("Bug on checkout", "CheckoutScreen");

// ❌ DON'T hardcode in source
let apiKey = "mbk_abc123..."
 
// ✅ DO use secure storage or config
let apiKey = ProcessInfo.processInfo.environment["MINIBACK_API_KEY"]
// Or use Keychain (iOS), EncryptedSharedPreferences (Android), etc.

async function submitWithRetry(message: string, maxRetries = 3) {
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      return await feedbackService.submitFeedback(message);
    } catch (error) {
      if (attempt === maxRetries) throw error;
      await new Promise(r => setTimeout(r, 1000 * attempt)); // Backoff
    }
  }
}

// Store feedback locally when offline
async function queueFeedback(message: string, context: FeedbackContext) {
  const isOnline = await NetInfo.fetch().then(state => state.isConnected);
  
  if (isOnline) {
    await feedbackService.submitFeedback(message, context);
  } else {
    // Store in local queue (AsyncStorage, SQLite, etc.)
    await storePendingFeedback({ message, context, timestamp: Date.now() });
  }
}
 
// Flush queue when back online
async function flushPendingFeedback() {
  const pending = await getPendingFeedback();
  for (const item of pending) {
    await feedbackService.submitFeedback(item.message, item.context);
    await removePendingFeedback(item.id);
  }
}

// Only include user identifiers if you have consent
const context = {
  ...deviceContext,
  // Only include if user opted in
  ...(hasAnalyticsConsent && { userId: currentUser.id }),
  ...(hasAnalyticsConsent && { userEmail: currentUser.email }),
};