MACRO NEPAL
Instabug for Mobile in Java: Complete Implementation Guide
awiskar acharya
November 26, 2025
1:02 pm

Introduction to Instabug

Instabug is a comprehensive mobile monitoring platform that provides bug reporting, crash reporting, in-app feedback, feature surveys, and performance monitoring for mobile applications. It helps developers quickly identify and resolve issues in their mobile apps.

Key Features

  • Bug Reporting: In-app screenshot and screen recording
  • Crash Reporting: Automatic crash detection with detailed context
  • Performance Monitoring: App launch time, network requests, UI responsiveness
  • Surveys & Feedback: In-app surveys and user feedback collection
  • Session Replay: User session recording for debugging
  • Real User Monitoring: Performance insights from real users

Android Implementation

Dependencies

Add to your app/build.gradle:

android {
compileSdk 33
defaultConfig {
applicationId "com.example.instabugdemo"
minSdk 21
targetSdk 33
versionCode 1
versionName "1.0.0"
}
}
dependencies {
// Instabug Core
implementation 'com.instabug.library:instabug:11.10.0'
// Instabug for APM (Application Performance Monitoring)
implementation 'com.instabug.library:instabug-apm:11.10.0'
// Instabug for Network Monitoring
implementation 'com.instabug.library:instabug-network-logging:11.10.0'
// Optional: Chat support
implementation 'com.instabug.library:instabug-chat:11.10.0'
// Optional: Surveys support
implementation 'com.instabug.library:instabug-surveys:11.10.0'
// AndroidX
implementation 'androidx.appcompat:appcompat:1.6.1'
implementation 'androidx.core:core-ktx:1.12.0'
implementation 'androidx.constraintlayout:constraintlayout:2.1.4'
// Networking (for demo)
implementation 'com.squareup.retrofit2:retrofit:2.9.0'
implementation 'com.squareup.retrofit2:converter-gson:2.9.0'
implementation 'com.squareup.okhttp3:logging-interceptor:4.11.0'
// Image loading (for demo)
implementation 'com.github.bumptech.glide:glide:4.15.1'
}
// Add this to your project-level build.gradle
allprojects {
repositories {
maven {
url "https://sdks.instabug.com/nexus/repository/instabug-cp"
}
}
}

Application Class Setup

package com.example.instabugdemo;
import android.app.Application;
import android.util.Log;
import com.instabug.bug.BugReporting;
import com.instabug.chat.Chats;
import com.instabug.crash.CrashReporting;
import com.instabug.apm.APM;
import com.instabug.library.Instabug;
import com.instabug.library.InstabugColorTheme;
import com.instabug.library.InstabugCustomTextPlaceHolder;
import com.instabug.library.OnSdkDismissedCallback;
import com.instabug.library.invocation.InstabugInvocationEvent;
import com.instabug.library.logging.InstabugLog;
import com.instabug.library.network.InstabugNetworkInterceptor;
import com.instabug.library.ui.onboarding.WelcomeMessage;
import com.instabug.library.InstabugCustomTextPlaceHolder.Key;
public class InstabugApplication extends Application {
private static final String TAG = "InstabugApplication";
private static final String INSTABUG_TOKEN = "YOUR_INSTABUG_TOKEN_HERE";
@Override
public void onCreate() {
super.onCreate();
// Initialize Instabug
initializeInstabug();
// Setup performance monitoring
setupPerformanceMonitoring();
// Setup network monitoring
setupNetworkMonitoring();
}
private void initializeInstabug() {
try {
new Instabug.Builder(this, INSTABUG_TOKEN)
.setInvocationEvents(
InstabugInvocationEvent.SHAKE,
InstabugInvocationEvent.SCREENSHOT,
InstabugInvocationEvent.FLOATING_BUTTON
)
.setTheme(InstabugColorTheme.Light)
.setWelcomeMessageState(WelcomeMessage.State.LIVE)
.setSdkDebugLogsLevel(Log.VERBOSE) // Use Log.ASSERT in production
.build();
// Configure Bug Reporting
BugReporting.setEnabled(true);
BugReporting.setInvocationEvents(
InstabugInvocationEvent.SHAKE,
InstabugInvocationEvent.SCREENSHOT
);
// Configure Crash Reporting
CrashReporting.setEnabled(true);
// Configure Chats
Chats.setState(Chats.State.ENABLED);
// Set custom placeholder texts
setCustomTextPlaceholders();
// Set user data
setUserData();
Log.d(TAG, "Instabug initialized successfully");
} catch (Exception e) {
Log.e(TAG, "Failed to initialize Instabug", e);
}
}
private void setCustomTextPlaceholders() {
InstabugCustomTextPlaceHolder placeHolder = new InstabugCustomTextPlaceHolder();
placeHolder.set(Key.REPORT_FEEDBACK, "Send Feedback");
placeHolder.set(Key.REPORT_BUG, "Report a Bug");
placeHolder.set(Key.REPORT_QUESTION, "Ask a Question");
placeHolder.set(Key.SHAKE_HINT, "Shake to report an issue");
placeHolder.set(Key.INVALID_EMAIL_MESSAGE, "Please enter a valid email");
placeHolder.set(Key.INVALID_COMMENT_MESSAGE, "Please add a description");
placeHolder.set(Key.REPORT_SUCCESSFULLY_SENT, "Thank you for your feedback!");
placeHolder.set(Key.REPORT_REPRODUCTION_STEPS, "What were you doing when the issue occurred?");
Instabug.setCustomTextPlaceHolders(placeHolder);
}
private void setUserData() {
// Set user data for better context in reports
Instabug.identifyUser("john_doe", "[email protected]");
Instabug.setUserAttribute("app_version", BuildConfig.VERSION_NAME);
Instabug.setUserAttribute("device_model", android.os.Build.MODEL);
Instabug.setUserAttribute("android_version", android.os.Build.VERSION.RELEASE);
// Add custom user attributes
Instabug.setUserAttribute("premium_user", "true");
Instabug.setUserAttribute("last_login", String.valueOf(System.currentTimeMillis()));
}
private void setupPerformanceMonitoring() {
// Enable APM (Application Performance Monitoring)
APM.setEnabled(true);
// Set performance monitoring callbacks
APM.setAPMListener(new APM.APMListener() {
@Override
public void onAppLaunchFinished(long duration) {
Log.d(TAG, "App launch duration: " + duration + "ms");
Instabug.setUserAttribute("app_launch_time", String.valueOf(duration));
}
@Override
public void onUIBlocked(long duration) {
Log.w(TAG, "UI blocked for: " + duration + "ms");
// You can set thresholds and take actions
if (duration > 1000) { // 1 second threshold
InstabugLog.w("UI blocked for " + duration + "ms");
}
}
});
// Start app launch tracking
APM.startAppLaunch();
}
private void setupNetworkMonitoring() {
// Network monitoring is automatically enabled
// You can configure it further if needed
}
public static void logDebug(String message) {
InstabugLog.d(message);
}
public static void logError(String message) {
InstabugLog.e(message);
}
public static void logWarning(String message) {
InstabugLog.w(message);
}
public static void logVerbose(String message) {
InstabugLog.v(message);
}
}

Main Activity with Instabug Integration

package com.example.instabugdemo;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;
import androidx.appcompat.app.AppCompatActivity;
import com.instabug.bug.BugReporting;
import com.instabug.chat.Chats;
import com.instabug.library.Instabug;
import com.instabug.library.OnSdkDismissedCallback;
import com.instabug.library.invocation.InstabugInvocationEvent;
import com.instabug.survey.Surveys;
import com.instabug.survey.callbacks.OnSurveyShowCallback;
public class MainActivity extends AppCompatActivity {
private static final String TAG = "MainActivity";
private TextView performanceStatus;
private Button crashButton;
private Button networkTestButton;
private Button customSurveyButton;
private Button startSessionReplayButton;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
initializeViews();
setupClickListeners();
setupPerformanceMonitoring();
checkForSurveys();
// Log app start
InstabugApplication.logDebug("MainActivity created");
}
private void initializeViews() {
performanceStatus = findViewById(R.id.performance_status);
crashButton = findViewById(R.id.crash_button);
networkTestButton = findViewById(R.id.network_test_button);
customSurveyButton = findViewById(R.id.custom_survey_button);
startSessionReplayButton = findViewById(R.id.start_session_replay_button);
}
private void setupClickListeners() {
crashButton.setOnClickListener(v -> simulateCrashScenario());
networkTestButton.setOnClickListener(v -> performNetworkOperations());
customSurveyButton.setOnClickListener(v -> showCustomSurvey());
startSessionReplayButton.setOnClickListener(v -> startSessionReplay());
// Manual bug report trigger
findViewById(R.id.manual_report_button).setOnClickListener(v -> {
showBugReporting();
});
// Chat trigger
findViewById(R.id.chat_button).setOnClickListener(v -> {
showChat();
});
}
private void setupPerformanceMonitoring() {
// Monitor cold start time
new Handler(Looper.getMainLooper()).postDelayed(() -> {
updatePerformanceStatus("App loaded successfully");
}, 1000);
}
private void updatePerformanceStatus(String status) {
runOnUiThread(() -> {
performanceStatus.setText(status);
performanceStatus.setVisibility(View.VISIBLE);
});
}
private void simulateCrashScenario() {
new Handler(Looper.getMainLooper()).postDelayed(() -> {
try {
// Simulate a potential crash scenario
String[] array = new String[5];
String element = array[10]; // This will cause ArrayIndexOutOfBoundsException
} catch (Exception e) {
// Log the exception to Instabug
InstabugApplication.logError("Simulated crash scenario: " + e.getMessage());
// Report non-fatal exception
Instabug.reportException(e);
updatePerformanceStatus("Crash scenario handled and reported");
}
}, 500);
}
private void performNetworkOperations() {
updatePerformanceStatus("Performing network operations...");
// Simulate network requests that will be monitored by Instabug
new Thread(() -> {
try {
// Simulate API calls
simulateApiCall("/api/users", 1000);
simulateApiCall("/api/products", 500);
simulateApiCall("/api/orders", 1500);
runOnUiThread(() -> 
updatePerformanceStatus("Network operations completed")
);
} catch (Exception e) {
InstabugApplication.logError("Network operation failed: " + e.getMessage());
runOnUiThread(() -> 
updatePerformanceStatus("Network operations failed")
);
}
}).start();
}
private void simulateApiCall(String endpoint, long delay) {
try {
Thread.sleep(delay);
// Log network request (this will be captured by Instabug)
InstabugApplication.logDebug("API call to " + endpoint + " completed in " + delay + "ms");
// Simulate random failures
if (Math.random() < 0.2) { // 20% failure rate for demo
throw new RuntimeException("Simulated API failure for " + endpoint);
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
} catch (Exception e) {
Instabug.reportException(e);
}
}
private void showCustomSurvey() {
// Check if there are available surveys
Surveys.showSurveyIfAvailable();
// Alternatively, you can show a specific survey
// Surveys.showSurvey("your_survey_token");
}
private void startSessionReplay() {
// Note: Session replay might require additional setup
updatePerformanceStatus("Session replay started");
// Add custom log for session start
InstabugApplication.logDebug("User started session replay");
}
private void showBugReporting() {
BugReporting.setReportTypes(
BugReporting.ReportType.BUG,
BugReporting.ReportType.FEEDBACK
);
BugReporting.invoke();
}
private void showChat() {
Chats.show();
}
private void checkForSurveys() {
Surveys.setOnShowCallback(new OnSurveyShowCallback() {
@Override
public void onSurveyShow(String surveyId) {
Log.d(TAG, "Survey shown: " + surveyId);
}
});
// Check for available surveys
Surveys.getAvailableSurveys((surveys) -> {
if (surveys != null && !surveys.isEmpty()) {
Log.d(TAG, "Available surveys: " + surveys.size());
// You can show a notification or badge
}
});
}
@Override
protected void onResume() {
super.onResume();
InstabugApplication.logDebug("MainActivity resumed");
// Track screen view
Instabug.trackScreenView("MainActivity");
}
@Override
protected void onPause() {
super.onPause();
InstabugApplication.logDebug("MainActivity paused");
}
}

Network Monitoring with Retrofit

package com.example.instabugdemo.network;
import android.util.Log;
import com.example.instabugdemo.InstabugApplication;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.logging.HttpLoggingInterceptor;
import retrofit2.Retrofit;
import retrofit2.converter.gson.GsonConverterFactory;
import java.io.IOException;
import java.util.concurrent.TimeUnit;
public class ApiClient {
private static final String TAG = "ApiClient";
private static final String BASE_URL = "https://api.example.com/";
private static Retrofit retrofit = null;
public static Retrofit getClient() {
if (retrofit == null) {
OkHttpClient.Builder httpClient = new OkHttpClient.Builder();
// Add Instabug network interceptor
httpClient.addInterceptor(new InstabugNetworkInterceptor());
// Add logging interceptor
HttpLoggingInterceptor logging = new HttpLoggingInterceptor(message -> 
InstabugApplication.logDebug("HTTP: " + message)
);
logging.setLevel(HttpLoggingInterceptor.Level.BODY);
httpClient.addInterceptor(logging);
// Add custom headers
httpClient.addInterceptor(chain -> {
Request original = chain.request();
Request request = original.newBuilder()
.header("User-Agent", "InstabugDemo/1.0.0")
.header("Accept", "application/json")
.method(original.method(), original.body())
.build();
return chain.proceed(request);
});
// Timeout configurations
httpClient.connectTimeout(30, TimeUnit.SECONDS);
httpClient.readTimeout(30, TimeUnit.SECONDS);
httpClient.writeTimeout(30, TimeUnit.SECONDS);
// Add response monitoring
httpClient.addNetworkInterceptor(chain -> {
long startTime = System.nanoTime();
Request request = chain.request();
Response response = chain.proceed(request);
long endTime = System.nanoTime();
long duration = (endTime - startTime) / 1_000_000; // Convert to milliseconds
// Log network performance
InstabugApplication.logDebug(
String.format("Network: %s %s - %dms - %d bytes",
request.method(),
request.url(),
duration,
response.body().contentLength())
);
return response;
});
retrofit = new Retrofit.Builder()
.baseUrl(BASE_URL)
.client(httpClient.build())
.addConverterFactory(GsonConverterFactory.create())
.build();
}
return retrofit;
}
}
// API Service Interface
package com.example.instabugdemo.network;
import retrofit2.Call;
import retrofit2.http.GET;
import retrofit2.http.Path;
import java.util.List;
public interface ApiService {
@GET("users")
Call<List<User>> getUsers();
@GET("users/{id}")
Call<User> getUser(@Path("id") String userId);
@GET("products")
Call<List<Product>> getProducts();
@GET("orders")
Call<List<Order>> getOrders();
}
// Usage in Activity/Fragment
package com.example.instabugdemo;
import android.os.Bundle;
import android.widget.Toast;
import androidx.appcompat.app.AppCompatActivity;
import com.example.instabugdemo.network.ApiClient;
import com.example.instabugdemo.network.ApiService;
import retrofit2.Call;
import retrofit2.Callback;
import retrofit2.Response;
import java.util.List;
public class NetworkActivity extends AppCompatActivity {
private ApiService apiService;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_network);
apiService = ApiClient.getClient().create(ApiService.class);
// Make sample API calls
fetchUsers();
fetchProducts();
}
private void fetchUsers() {
InstabugApplication.logDebug("Fetching users...");
Call<List<User>> call = apiService.getUsers();
call.enqueue(new Callback<List<User>>() {
@Override
public void onResponse(Call<List<User>> call, Response<List<User>> response) {
if (response.isSuccessful()) {
List<User> users = response.body();
InstabugApplication.logDebug("Fetched " + users.size() + " users");
Toast.makeText(NetworkActivity.this, 
"Users loaded: " + users.size(), Toast.LENGTH_SHORT).show();
} else {
InstabugApplication.logError("Failed to fetch users: " + response.code());
}
}
@Override
public void onFailure(Call<List<User>> call, Throwable t) {
InstabugApplication.logError("Network error fetching users: " + t.getMessage());
Toast.makeText(NetworkActivity.this, 
"Network error", Toast.LENGTH_SHORT).show();
// Report network failure to Instabug
Instabug.reportException(t);
}
});
}
private void fetchProducts() {
InstabugApplication.logDebug("Fetching products...");
Call<List<Product>> call = apiService.getProducts();
call.enqueue(new Callback<List<Product>>() {
@Override
public void onResponse(Call<List<Product>> call, Response<List<Product>> response) {
if (response.isSuccessful()) {
List<Product> products = response.body();
InstabugApplication.logDebug("Fetched " + products.size() + " products");
} else {
InstabugApplication.logError("Failed to fetch products: " + response.code());
}
}
@Override
public void onFailure(Call<List<Product>> call, Throwable t) {
InstabugApplication.logError("Network error fetching products: " + t.getMessage());
Instabug.reportException(t);
}
});
}
}

Custom Bug Reporting with Additional Context

package com.example.instabugdemo.bugreporting;
import android.content.Context;
import android.util.Log;
import com.instabug.bug.BugReporting;
import com.instabug.library.Instabug;
import com.instabug.library.OnSdkDismissedCallback;
import com.instabug.library.model.Report;
import org.json.JSONObject;
import java.util.HashMap;
import java.util.Map;
public class CustomBugReporter {
private static final String TAG = "CustomBugReporter";
public static void reportBugWithContext(Context context, String title, String description) {
reportBugWithContext(context, title, description, null);
}
public static void reportBugWithContext(Context context, String title, 
String description, Map<String, String> additionalData) {
try {
// Set report type
BugReporting.setReportTypes(BugReporting.ReportType.BUG);
// Add custom fields
if (additionalData != null) {
for (Map.Entry<String, String> entry : additionalData.entrySet()) {
Instabug.setUserAttribute(entry.getKey(), entry.getValue());
}
}
// Set custom invocation event callback
BugReporting.setOnInvokeCallback(() -> {
Log.d(TAG, "Bug reporting invoked");
// You can add pre-reporting logic here
});
BugReporting.setOnDismissCallback(new OnSdkDismissedCallback() {
@Override
public void onSdkDismissed(DismissType dismissType, Report.Type reportType) {
Log.d(TAG, "Bug reporting dismissed: " + dismissType);
switch (dismissType) {
case SUBMIT:
Log.d(TAG, "Bug report submitted");
// Perform any post-submission actions
break;
case CANCEL:
Log.d(TAG, "Bug report cancelled");
break;
case ADD_ATTACHMENT:
Log.d(TAG, "User added attachment");
break;
}
}
});
// Invoke bug reporting with pre-filled description
BugReporting.invoke(title, description);
} catch (Exception e) {
Log.e(TAG, "Error reporting bug", e);
}
}
public static void reportPerformanceIssue(Context context, String issueType, 
long duration, Map<String, Object> metrics) {
Map<String, String> additionalData = new HashMap<>();
additionalData.put("issue_type", issueType);
additionalData.put("duration_ms", String.valueOf(duration));
additionalData.put("timestamp", String.valueOf(System.currentTimeMillis()));
if (metrics != null) {
for (Map.Entry<String, Object> entry : metrics.entrySet()) {
additionalData.put("metric_" + entry.getKey(), 
entry.getValue() != null ? entry.getValue().toString() : "null");
}
}
String description = String.format(
"Performance Issue Detected\nType: %s\nDuration: %dms\nMetrics: %s",
issueType, duration, new JSONObject(metrics).toString()
);
reportBugWithContext(context, "Performance Issue: " + issueType, description, additionalData);
}
public static void reportNetworkIssue(Context context, String url, 
int statusCode, String errorMessage, long responseTime) {
Map<String, String> additionalData = new HashMap<>();
additionalData.put("network_url", url);
additionalData.put("status_code", String.valueOf(statusCode));
additionalData.put("response_time_ms", String.valueOf(responseTime));
additionalData.put("error_message", errorMessage);
String description = String.format(
"Network Issue\nURL: %s\nStatus: %d\nResponse Time: %dms\nError: %s",
url, statusCode, responseTime, errorMessage
);
reportBugWithContext(context, "Network Issue: " + statusCode, description, additionalData);
}
public static void setCustomUserData(String userId, String userRole, String appVersion) {
// Identify user
Instabug.identifyUser(userId, userId + "@example.com");
// Set user attributes
Instabug.setUserAttribute("user_role", userRole);
Instabug.setUserAttribute("app_version", appVersion);
Instabug.setUserAttribute("device_model", android.os.Build.MODEL);
Instabug.setUserAttribute("android_version", android.os.Build.VERSION.RELEASE);
// Add session-specific data
Instabug.setUserAttribute("session_start_time", String.valueOf(System.currentTimeMillis()));
}
}

Performance Monitoring Service

package com.example.instabugdemo.performance;
import android.app.Activity;
import android.os.Handler;
import android.os.Looper;
import android.util.Log;
import com.instabug.apm.APM;
import com.instabug.library.Instabug;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
public class PerformanceMonitor {
private static final String TAG = "PerformanceMonitor";
private static final Map<String, Long> traceStartTimes = new ConcurrentHashMap<>();
private static final Map<String, Map<String, Object>> traceMetadata = new ConcurrentHashMap<>();
private static final Handler mainHandler = new Handler(Looper.getMainLooper());
public static void startTrace(String traceName) {
startTrace(traceName, null);
}
public static void startTrace(String traceName, Map<String, Object> metadata) {
long startTime = System.currentTimeMillis();
traceStartTimes.put(traceName, startTime);
if (metadata != null) {
traceMetadata.put(traceName, metadata);
}
Log.d(TAG, "Started trace: " + traceName);
Instabug.logVerbose("Trace started: " + traceName);
}
public static void endTrace(String traceName) {
endTrace(traceName, null);
}
public static void endTrace(String traceName, Map<String, Object> additionalData) {
Long startTime = traceStartTimes.remove(traceName);
if (startTime == null) {
Log.w(TAG, "Trace not found: " + traceName);
return;
}
long endTime = System.currentTimeMillis();
long duration = endTime - startTime;
Map<String, Object> traceData = new HashMap<>();
traceData.put("duration", duration);
traceData.put("start_time", startTime);
traceData.put("end_time", endTime);
// Add original metadata
Map<String, Object> metadata = traceMetadata.remove(traceName);
if (metadata != null) {
traceData.putAll(metadata);
}
// Add additional data
if (additionalData != null) {
traceData.putAll(additionalData);
}
// Log performance data
Log.d(TAG, String.format("Trace %s completed in %dms", traceName, duration));
Instabug.logDebug(String.format("Performance: %s - %dms", traceName, duration));
// Report slow traces
if (duration > 1000) { // 1 second threshold
Instabug.logWarn(String.format("Slow trace detected: %s - %dms", traceName, duration));
// You can automatically report performance issues
if (duration > 5000) { // 5 seconds threshold
reportPerformanceIssue(traceName, duration, traceData);
}
}
// Update user attribute for monitoring
Instabug.setUserAttribute("last_trace_" + traceName, String.valueOf(duration));
}
private static void reportPerformanceIssue(String traceName, long duration, Map<String, Object> traceData) {
// This would integrate with your bug reporting
Map<String, String> bugData = new HashMap<>();
bugData.put("trace_name", traceName);
bugData.put("duration_ms", String.valueOf(duration));
bugData.put("issue_type", "performance_slow_trace");
// Convert trace data to string for bug report
StringBuilder traceInfo = new StringBuilder();
for (Map.Entry<String, Object> entry : traceData.entrySet()) {
traceInfo.append(entry.getKey()).append(": ").append(entry.getValue()).append("\n");
}
// You can invoke custom bug reporting here
Log.w(TAG, "Performance issue detected for trace: " + traceName);
}
public static void monitorActivityLaunch(Activity activity, String activityName) {
startTrace("activity_launch_" + activityName);
// Monitor when activity becomes fully visible
mainHandler.postDelayed(() -> {
endTrace("activity_launch_" + activityName);
}, 1000); // Adjust based on your needs
}
public static void monitorNetworkRequest(String requestId, String url, String method) {
Map<String, Object> metadata = new HashMap<>();
metadata.put("url", url);
metadata.put("method", method);
metadata.put("request_id", requestId);
startTrace("network_request_" + requestId, metadata);
}
public static void endNetworkRequest(String requestId, int statusCode, long contentLength) {
Map<String, Object> additionalData = new HashMap<>();
additionalData.put("status_code", statusCode);
additionalData.put("content_length", contentLength);
endTrace("network_request_" + requestId, additionalData);
}
public static void monitorDatabaseOperation(String operation, String table) {
Map<String, Object> metadata = new HashMap<>();
metadata.put("operation", operation);
metadata.put("table", table);
startTrace("database_" + operation + "_" + table, metadata);
}
public static void endDatabaseOperation(String operation, String table) {
endTrace("database_" + operation + "_" + table);
}
}

Layout Files

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<ScrollView xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:padding="16dp"
android:background="#f5f5f5">
<LinearLayout
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:orientation="vertical">
<!-- Header -->
<TextView
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:text="Instabug Demo"
android:textSize="24sp"
android:textStyle="bold"
android:gravity="center"
android:layout_marginBottom="24dp"
android:textColor="#333333" />
<!-- Performance Status -->
<TextView
android:id="@+id/performance_status"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:text="Performance monitoring active..."
android:textSize="14sp"
android:padding="12dp"
android:background="#e8f5e8"
android:textColor="#2e7d32"
android:visibility="gone"
android:layout_marginBottom="16dp" />
<!-- Crash Simulation -->
<Button
android:id="@+id/crash_button"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:text="Simulate Crash Scenario"
android:textColor="#ffffff"
android:background="#ff4444"
android:layout_marginBottom="8dp" />
<!-- Network Test -->
<Button
android:id="@+id/network_test_button"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:text="Test Network Operations"
android:textColor="#ffffff"
android:background="#2196F3"
android:layout_marginBottom="8dp" />
<!-- Manual Bug Report -->
<Button
android:id="@+id/manual_report_button"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:text="Report Bug Manually"
android:textColor="#ffffff"
android:background="#FF9800"
android:layout_marginBottom="8dp" />
<!-- Chat -->
<Button
android:id="@+id/chat_button"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:text="Start Chat"
android:textColor="#ffffff"
android:background="#4CAF50"
android:layout_marginBottom="8dp" />
<!-- Surveys -->
<Button
android:id="@+id/custom_survey_button"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:text="Show Survey"
android:textColor="#ffffff"
android:background="#9C27B0"
android:layout_marginBottom="8dp" />
<!-- Session Replay -->
<Button
android:id="@+id/start_session_replay_button"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:text="Start Session Replay"
android:textColor="#ffffff"
android:background="#607D8B"
android:layout_marginBottom="16dp" />
<!-- Instructions -->
<TextView
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:text="Try these gestures to trigger Instabug:\n• Shake device\n• Take screenshot\n• Tap floating button (if enabled)"
android:textSize="12sp"
android:textColor="#666666"
android:lineSpacingExtra="4dp"
android:padding="8dp" />
</LinearLayout>
</ScrollView>

Advanced Configuration

ProGuard Rules (proguard-rules.pro)

# Instabug ProGuard Rules
-keep class com.instabug.** { *; }
-dontwarn com.instabug.**
# Keep custom application class
-keep public class com.example.instabugdemo.InstabugApplication
# Keep methods used in Instabug callbacks
-keepclassmembers class * {
@com.instabug.library.internal.module.InstabugMethod *;
}
# Keep annotation classes
-keepattributes *Annotation*
# For network logging
-keep class okhttp3.** { *; }
-keep class retrofit2.** { *; }
-dontwarn okhttp3.**
-dontwarn retrofit2.**
-keep class com.google.gson.** { *; }
-keep class com.google.** { *; }

Advanced Instabug Configuration

package com.example.instabugdemo.config;
import android.app.Application;
import com.instabug.bug.BugReporting;
import com.instabug.bug.invocation.Option;
import com.instabug.chat.Chats;
import com.instabug.chat.Replies;
import com.instabug.crash.CrashReporting;
import com.instabug.library.Instabug;
import com.instabug.library.InstabugColorTheme;
import com.instabug.library.invocation.InstabugInvocationEvent;
import com.instabug.library.ui.onboarding.WelcomeMessage;
import com.instabug.survey.Surveys;
public class AdvancedInstabugConfig {
public static void configure(Application application, String token) {
try {
new Instabug.Builder(application, token)
.setInvocationEvents(
InstabugInvocationEvent.SHAKE,
InstabugInvocationEvent.SCREENSHOT,
InstabugInvocationEvent.TWO_FINGER_SWIPE_LEFT
)
.setTheme(InstabugColorTheme.Light)
.setWelcomeMessageState(WelcomeMessage.State.BETA)
.setTrackingUserStepsState(Instabug.TrackingState.ENABLED)
.setConsoleLogState(Instabug.TrackingState.ENABLED)
.setUserResponseEnabled(true)
.setSessionProfilerState(Instabug.TrackingState.ENABLED)
.setViewHierarchyState(Instabug.TrackingState.ENABLED)
.setDebugEnabled(true)
.build();
// Advanced Bug Reporting Configuration
BugReporting.setEnabled(true);
BugReporting.setOptions(Option.COMMENT_FIELD_REQUIRED);
BugReporting.setFloatingButtonEdge(BugReporting.FloatingButtonEdge.LEFT);
BugReporting.setShakingThreshold(2500); // Very sensitive
// Crash Reporting
CrashReporting.setEnabled(true);
// Chats & Replies
Chats.setState(Chats.State.ENABLED_WITH_ATTACHMENTS);
Replies.setState(Replies.State.ENABLED);
// Surveys
Surveys.setEnabled(true);
Surveys.setAppStoreURL("https://play.google.com/store/apps/details?id=com.example.instabugdemo");
// Feature Requests
com.instabug.featuresrequest.FeatureRequests.setEnabled(true);
} catch (Exception e) {
// Handle configuration errors
e.printStackTrace();
}
}
public static void setCustomInvocationEvents() {
// Custom invocation events for specific scenarios
Instabug.setInvocationEvents(
InstabugInvocationEvent.SHAKE,
InstabugInvocationEvent.SCREENSHOT,
InstabugInvocationEvent.FLOATING_BUTTON
);
}
}

Testing and Debugging

Test Activity for Instabug Features

package com.example.instabugdemo;
import android.os.Bundle;
import android.widget.Button;
import android.widget.LinearLayout;
import androidx.appcompat.app.AppCompatActivity;
public class TestActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
LinearLayout layout = new LinearLayout(this);
layout.setOrientation(LinearLayout.VERTICAL);
// Add test buttons for various scenarios
addTestButton(layout, "Test Network Error", this::testNetworkError);
addTestButton(layout, "Test UI Freeze", this::testUIFreeze);
addTestButton(layout, "Test Memory Warning", this::testMemoryWarning);
addTestButton(layout, "Test Custom Logs", this::testCustomLogs);
setContentView(layout);
}
private void addTestButton(LinearLayout layout, String text, Runnable action) {
Button button = new Button(this);
button.setText(text);
button.setOnClickListener(v -> action.run());
layout.addView(button);
}
private void testNetworkError() {
// Simulate network error
new Thread(() -> {
try {
throw new RuntimeException("Simulated network error");
} catch (Exception e) {
Instabug.reportException(e);
}
}).start();
}
private void testUIFreeze() {
// Simulate UI freeze
try {
Thread.sleep(5000); // Freeze UI for 5 seconds
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
private void testMemoryWarning() {
// Simulate memory pressure
byte[] memoryHog = new byte[100 * 1024 * 1024]; // 100MB
InstabugApplication.logWarning("Memory test completed");
}
private void testCustomLogs() {
// Test different log levels
InstabugApplication.logVerbose("Verbose log message");
InstabugApplication.logDebug("Debug log message");
InstabugApplication.logWarning("Warning log message");
InstabugApplication.logError("Error log message");
}
}

Best Practices

1. Environment-specific Configuration

public class InstabugConfigManager {
public static void initialize(Application application, BuildType buildType) {
String token;
boolean debugEnabled;
switch (buildType) {
case DEBUG:
token = "DEBUG_TOKEN";
debugEnabled = true;
break;
case STAGING:
token = "STAGING_TOKEN";
debugEnabled = true;
break;
case RELEASE:
token = "RELEASE_TOKEN";
debugEnabled = false;
break;
default:
token = "DEBUG_TOKEN";
debugEnabled = true;
}
new Instabug.Builder(application, token)
.setDebugEnabled(debugEnabled)
.build();
}
public enum BuildType {
DEBUG, STAGING, RELEASE
}
}

2. User Session Management

public class UserSessionManager {
public static void startUserSession(String userId, String userEmail) {
Instabug.identifyUser(userId, userEmail);
Instabug.setUserAttribute("session_start", String.valueOf(System.currentTimeMillis()));
Instabug.setUserAttribute("device_id", getDeviceId());
}
public static void endUserSession() {
Instabug.logout();
}
public static void updateUserProfile(String name, Map<String, String> customAttributes) {
Instabug.setUserName(name);
for (Map.Entry<String, String> entry : customAttributes.entrySet()) {
Instabug.setUserAttribute(entry.getKey(), entry.getValue());
}
}
private static String getDeviceId() {
// Implementation to get device ID
return android.provider.Settings.Secure.getString(
getContentResolver(),
android.provider.Settings.Secure.ANDROID_ID
);
}
}

Conclusion

This comprehensive Instabug implementation for Android provides:

  • Complete setup and configuration for all Instabug features
  • Performance monitoring with custom traces and metrics
  • Network monitoring with Retrofit integration
  • Custom bug reporting with additional context
  • User session management for better debugging
  • Testing utilities for development and QA

Key benefits include reduced time to detect and resolve issues, improved user experience through performance monitoring, and comprehensive insights into app behavior through session replays and user feedback.

Remember to:

  • Use different tokens for different build types
  • Configure appropriate invocation events for your app
  • Add meaningful user data for better context
  • Monitor performance metrics and set appropriate thresholds
  • Test all Instabug features thoroughly before release
  • Follow privacy guidelines when collecting user data
Category : JAVA

Leave a Reply

Your email address will not be published. Required fields are marked *


Macro Nepal Helper