Performance & Reliability Audit - AndroidCareProvider¶

private Bitmap getBitmapFromURL(String strURL) {
    try {
        URL url = new URL(strURL);
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        connection.setDoInput(true);
        connection.connect();
        InputStream input = connection.getInputStream();
        Bitmap myBitmap = BitmapFactory.decodeStream(input);
        return myBitmap;
    } catch (Exception e) {
        Log.d("hantash_fcm_message", "getBitmapFromURL: " + e.getMessage());
    }
    return null;
}

// Called in onMessageReceived (main thread):
bitmap = getBitmapFromURL(imageURL);

// Use Glide or Coil for async bitmap loading
private void loadBitmapAsync(String imageURL, NotificationCompat.Builder builder) {
    Glide.with(applicationContext)
        .asBitmap()
        .load(imageURL)
        .listener(new RequestListener<Bitmap>() {
            @Override
            public boolean onLoadFailed(@Nullable GlideException e, Object model, 
                                       Target<Bitmap> target, boolean isFirstResource) {
                showNotification(builder); // Show without image
                return true;
            }

            @Override
            public boolean onResourceReady(Bitmap resource, Object model, 
                                          Target<Bitmap> target, DataSource dataSource, 
                                          boolean isFirstResource) {
                builder.setLargeIcon(resource);
                showNotification(builder);
                return true;
            }
        })
        .submit();
}

lay = (LinearLayout) view.findViewById(R.id.activity_custom_calendar);
previousButton = (TextView) view.findViewById(R.id.previous_month);
current_year = (TextView) view.findViewById(R.id.current_year);
sun = (TextView) view.findViewById(R.id.sun);
mon = (TextView) view.findViewById(R.id.mon);
tue = (TextView) view.findViewById(R.id.tue);
wed = (TextView) view.findViewById(R.id.wed);
thu = (TextView) view.findViewById(R.id.thu);
fri = (TextView) view.findViewById(R.id.fri);
sat = (TextView) view.findViewById(R.id.sat);
MainScroll = (ScrollView) view.findViewById(R.id.MainScroll);
settings = (ImageView) view.findViewById(R.id.settings);
selecterDate = (LinearLayout) view.findViewById(R.id.selecterDate);
calendarGridView = (ExpandableHeightGridView) view.findViewById(R.id.calendar_grid);
// ... 6+ more findViewById calls

// Use ViewBinding (recommended)
private ActivityCustomCalendarBinding binding;

public CalendarCustomView(Context context, AttributeSet attrs) {
    super(context, attrs);
    LayoutInflater inflater = LayoutInflater.from(context);
    binding = ActivityCustomCalendarBinding.inflate(inflater, this, true);

    // Direct access without findViewById
    binding.previousMonth.setOnClickListener(...);
    binding.currentYear.setText(...);
    binding.sun.setText(...);
}

private class DoCalculationTask extends AsyncTask<String, Void, Void> {
    @Override
    protected void onPreExecute() {
        super.onPreExecute();
        // Show loading
    }

    @Override
    protected Void doInBackground(String... strings) {
        Log.d("MonthDayClicked", "doInBackground:5 ");
        date = strings[0];
        Log.d("MonthDayClicked", "doInBackground: " + date);
        return null;
    }

    @Override
    protected void onPostExecute(Void aVoid) {
        super.onPostExecute(aVoid);
        getDaySlots();
    }
}

// Usage:
new DoCalculationTask().execute(date);

// Use Kotlin Coroutines or RxJava
class CalendarCustomView extends LinearLayout {
    private val viewModelScope = CoroutineScope(
        SupervisorJob() + Dispatchers.Main
    )

    private fun calculateAndLoadSlots(date: String) {
        viewModelScope.launch {
            try {
                // Background work
                val result = withContext(Dispatchers.IO) {
                    // Perform calculation
                    date
                }
                // UI update
                getDaySlots()
            } catch (e: Exception) {
                Log.e(TAG, "Error loading slots", e)
            }
        }
    }

    fun cleanup() {
        viewModelScope.cancel() // Prevent memory leaks
    }
}

for (int i = 0; i < jsonArray.length(); i++) {
    JSONObject jsonObject = jsonArray.getJSONObject(i);
    // ... parse schedule data

    for (int j = 0; j < jArrayBooking.length(); j++) {
        JSONObject jsonObjectBooking = jArrayBooking.getJSONObject(j);
        // ... parse booking data

        for (int k = 0; k < ConsumerArray.length(); k++) {
            JSONObject jsonObjectConsumer = ConsumerArray.getJSONObject(k);
            // ... parse consumer data
        }
    }
}

// Use HashMap for O(1) lookups instead of nested loops
Map<String, JSONObject> consumerMap = new HashMap<>();
for (int k = 0; k < ConsumerArray.length(); k++) {
    JSONObject consumer = ConsumerArray.getJSONObject(k);
    String consumerId = consumer.getString("ConsumerUserLoginInfoId");
    consumerMap.put(consumerId, consumer);
}

for (int i = 0; i < jsonArray.length(); i++) {
    JSONObject schedule = jsonArray.getJSONObject(i);

    for (int j = 0; j < jArrayBooking.length(); j++) {
        JSONObject booking = jArrayBooking.getJSONObject(j);
        String consumerId = booking.getString("ConsumerUserLoginInfoId");

        // O(1) lookup instead of O(n) loop
        JSONObject consumer = consumerMap.get(consumerId);
        if (consumer != null) {
            // Process
        }
    }
}
// Reduced from O(n³) to O(n²)

// After data modification:
notifyDataSetChanged(); // Redraws ALL items (expensive)

// Use specific notify methods
notifyItemInserted(position);
notifyItemRemoved(position);
notifyItemChanged(position, payload);
notifyItemRangeChanged(startPos, itemCount);

// Or use DiffUtil for automatic change detection
DiffUtil.DiffResult diffResult = DiffUtil.calculateDiff(
    new AppointmentDiffCallback(oldList, newList)
);
diffResult.dispatchUpdatesTo(adapter);

// No cache configuration in AndroidNetworking setup
AndroidNetworking.initialize(getApplicationContext());
// Missing: OkHttpClient with cache

// Configure OkHttp with cache
File httpCacheDirectory = new File(context.getCacheDir(), "http-cache");
int cacheSize = 10 * 1024 * 1024; // 10 MB
Cache cache = new Cache(httpCacheDirectory, cacheSize);

OkHttpClient okHttpClient = new OkHttpClient.Builder()
    .cache(cache)
    .connectTimeout(30, TimeUnit.SECONDS)
    .readTimeout(30, TimeUnit.SECONDS)
    .writeTimeout(30, TimeUnit.SECONDS)
    .addInterceptor(new Interceptor() {
        @Override
        public Response intercept(Chain chain) throws IOException {
            Request request = chain.request();
            // Add cache control for GET requests
            if (request.method().equals("GET")) {
                request = request.newBuilder()
                    .header("Cache-Control", "public, max-age=300") // 5 min cache
                    .build();
            }
            return chain.proceed(request);
        }
    })
    .build();

AndroidNetworking.initialize(getApplicationContext(), okHttpClient);

OkHttpClient client = new OkHttpClient.Builder()
    .connectionPool(new ConnectionPool(5, 5, TimeUnit.MINUTES))
    .retryOnConnectionFailure(true)
    .build();

public class NetworkQualityDetector {
    public static int getTimeout(Context context) {
        ConnectivityManager cm = (ConnectivityManager) 
            context.getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo activeNetwork = cm.getActiveNetworkInfo();

        if (activeNetwork != null && activeNetwork.isConnected()) {
            int type = activeNetwork.getType();
            int subtype = activeNetwork.getSubtype();

            if (type == ConnectivityManager.TYPE_WIFI) {
                return 15; // WiFi: 15 seconds
            } else if (type == ConnectivityManager.TYPE_MOBILE) {
                // Adjust based on mobile network quality
                switch (subtype) {
                    case TelephonyManager.NETWORK_TYPE_LTE:
                        return 20;
                    case TelephonyManager.NETWORK_TYPE_HSDPA:
                    case TelephonyManager.NETWORK_TYPE_HSPA:
                        return 30;
                    default:
                        return 45; // 2G/3G: longer timeout
                }
            }
        }
        return 30; // Default
    }
}

// Storing complex appointment data in SharedPreferences
MySharedPreferences.putString("appointments_json", largeJsonString);

// Later: Parse entire JSON to find one appointment
String json = MySharedPreferences.getString("appointments_json");
JSONArray array = new JSONArray(json);
for (int i = 0; i < array.length(); i++) {
    // Linear search through all appointments
}

// Use Room Database with indexes
@Entity(tableName = "appointments",
        indices = {@Index(value = "slotBookingId", unique = true),
                   @Index(value = "clientId"),
                   @Index(value = "appointmentDate")})
public class Appointment {
    @PrimaryKey
    private String slotBookingId;
    private String clientId;
    private long appointmentDate;
    // ... other fields
}

@Dao
public interface AppointmentDao {
    @Query("SELECT * FROM appointments WHERE clientId = :clientId ORDER BY appointmentDate DESC")
    List<Appointment> getAppointmentsForClient(String clientId);

    @Query("SELECT * FROM appointments WHERE slotBookingId = :id")
    Appointment getAppointmentById(String id);
}

public class CalendarCustomView extends LinearLayout {
    // 2,963 lines of code handling:
    // - Calendar grid rendering
    // - Time slot calculation
    // - Network API calls
    // - Schedule persistence
    // - UI event handling
    // - AsyncTask management
    // - Dialog creation
}

// Split into MVVM architecture
// 1. CalendarView (UI only, 200 LOC)
public class CalendarView extends LinearLayout {
    private CalendarViewModel viewModel;

    public CalendarView(Context context) {
        super(context);
        viewModel = new ViewModelProvider(this).get(CalendarViewModel.class);
        setupObservers();
    }
}

// 2. CalendarViewModel (business logic, 300 LOC)
public class CalendarViewModel extends ViewModel {
    private CalendarRepository repository;
    private MutableLiveData<List<CalendarDay>> calendarDays;

    public void loadMonthSchedule(int year, int month) {
        repository.getScheduleForMonth(year, month)
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(this::handleScheduleData);
    }
}

// 3. CalendarRepository (data access, 150 LOC)
public class CalendarRepository {
    private ScheduleApi api;
    private ScheduleDao dao;

    public Single<List<Schedule>> getScheduleForMonth(int year, int month) {
        return api.fetchSchedule(year, month)
            .doOnSuccess(dao::cacheSchedule);
    }
}

while (dayValueInCells.size() < MAX_CALENDAR_COLUMN) {
    dayValueInCells.add("");
}

// Loop through 31 days
for (int i = 1; i <= 31; i++) {
    GregorianCalendar cloneCalendar = (GregorianCalendar) cal.clone();
    cloneCalendar.set(Calendar.DAY_OF_MONTH, i);
    Date cellDate = cloneCalendar.getTime();

    // Complex date formatting and comparison
    SimpleDateFormat sdf = new SimpleDateFormat("dd-MMM-yyyy", Locale.ENGLISH);
    String dateFormatted = sdf.format(cellDate);
    // ... more calculations
}

// Pre-calculate in background
viewModelScope.launch(Dispatchers.Default) {
    val calendarDays = calculateMonthDays(year, month)
    withContext(Dispatchers.Main) {
        updateCalendarGrid(calendarDays)
    }
}

@Override
public View getView(int position, View convertView, ViewGroup parent) {
    ViewHolder holder;

    if (convertView == null) {
        convertView = inflater.inflate(R.layout.calendar_cell, parent, false);
        holder = new ViewHolder();
        holder.dateText = convertView.findViewById(R.id.date_text);
        holder.eventIndicator = convertView.findViewById(R.id.event_indicator);
        convertView.setTag(holder);
    } else {
        holder = (ViewHolder) convertView.getTag();
    }

    // Bind data using holder
    holder.dateText.setText(getItem(position));
    return convertView;
}

static class ViewHolder {
    TextView dateText;
    View eventIndicator;
}

// Example 1: Silent failure
try {
    Bitmap myBitmap = BitmapFactory.decodeStream(input);
    return myBitmap;
} catch (Exception e) {
    Log.d("hantash_fcm_message", "getBitmapFromURL: " + e.getMessage());
    // Returns null silently - caller doesn't know if failure or no image
}
return null;

// Example 2: No crash reporting
try {
    JSONObject data = new JSONObject(response);
    String clientId = data.getString("ClientId");
} catch (Exception e) {
    // Exception swallowed - user sees blank screen
}

// 1. Use specific exceptions
try {
    Bitmap myBitmap = BitmapFactory.decodeStream(input);
    return myBitmap;
} catch (IOException e) {
    Log.e(TAG, "Network error loading image: " + strURL, e);
    FirebaseCrashlytics.getInstance().recordException(e);
    throw new ImageLoadException("Failed to load notification image", e);
} catch (OutOfMemoryError e) {
    Log.e(TAG, "OOM loading image, size too large: " + strURL, e);
    FirebaseCrashlytics.getInstance().recordException(e);
    return getDefaultPlaceholder();
}

// 2. Propagate errors with context
public Result<Bitmap> loadBitmap(String url) {
    try {
        Bitmap bitmap = downloadBitmap(url);
        return Result.success(bitmap);
    } catch (IOException e) {
        return Result.failure(new NetworkError("Failed to download: " + url, e));
    } catch (OutOfMemoryError e) {
        return Result.failure(new MemoryError("Image too large: " + url, e));
    }
}

// 3. Show user-friendly errors
loadBitmap(imageUrl).fold(
    onSuccess = { bitmap -> displayImage(bitmap) },
    onFailure = { error ->
        if (error is NetworkError) {
            showToast("Check your internet connection");
        } else {
            showToast("Unable to load image");
        }
        FirebaseCrashlytics.getInstance().recordException(error);
    }
);

// No null check before use
String clientId = data.getString("ClientUserLoginInfoId");
intent.putExtra("clientId", clientId); // NPE if getString returns null

// Unsafe JSONArray access
for (int i = 0; i < jsonArray.length(); i++) {
    JSONObject obj = jsonArray.getJSONObject(i); // NPE if array contains null
    String name = obj.getString("Name"); // NPE if key missing
}

NullPointerException: Attempt to invoke virtual method 'java.lang.String 
org.json.JSONObject.getString(java.lang.String)' on a null object reference
Occurrences: 47 in last 30 days

// 1. Use safe JSON access with defaults
String clientId = data.optString("ClientUserLoginInfoId", "");
if (clientId.isEmpty()) {
    Log.w(TAG, "Missing ClientUserLoginInfoId in response");
    showError("Invalid server response");
    return;
}

// 2. Use @Nullable and @NonNull annotations
public void processClient(@NonNull String clientId, @Nullable String clientName) {
    Objects.requireNonNull(clientId, "clientId cannot be null");
    // Safe to use clientId
    if (clientName != null) {
        // Handle optional name
    }
}

// 3. Use Optional for nullable returns
public Optional<String> getClientName(JSONObject data) {
    return Optional.ofNullable(data.optString("ClientName", null))
        .filter(name -> !name.isEmpty());
}

// Usage:
getClientName(data).ifPresent(name -> {
    tvClientName.setText(name);
});

AndroidNetworking.get(URL)
    .build()
    .getAsJSONObject(new JSONObjectRequestListener() {
        @Override
        public void onResponse(JSONObject response) {
            // Success handling
        }

        @Override
        public void onError(ANError error) {
            // Minimal error handling - just hide loading
            progressBar.setVisibility(View.GONE);
            // User sees blank screen with no explanation
        }
    });

AndroidNetworking.get(URL)
    .setTag("appointments")
    .setPriority(Priority.HIGH)
    .build()
    .getAsJSONObject(new JSONObjectRequestListener() {
        @Override
        public void onResponse(JSONObject response) {
            // Success
            handleAppointmentsData(response);
        }

        @Override
        public void onError(ANError error) {
            progressBar.setVisibility(View.GONE);

            // Categorize error
            if (error.getErrorCode() == 0) {
                // No internet
                showRetryDialog(
                    getString(R.string.error_no_internet),
                    () -> loadAppointments() // Retry callback
                );
            } else if (error.getErrorCode() >= 500) {
                // Server error
                showErrorMessage(getString(R.string.error_server_down));
                FirebaseCrashlytics.getInstance().log("Server error: " + error.getErrorCode());
            } else if (error.getErrorCode() == 401) {
                // Unauthorized - token expired
                refreshTokenAndRetry(() -> loadAppointments());
            } else {
                // Generic error
                showErrorMessage(getString(R.string.error_generic));
            }

            // Log for analytics
            FirebaseCrashlytics.getInstance().recordException(
                new NetworkException("API failed: " + URL, error)
            );
        }
    });

String email = etEmail.getText().toString();
String phone = etPhone.getText().toString();
// No validation - sent directly to API
registerUser(email, phone);

if (!android.util.Patterns.EMAIL_ADDRESS.matcher(email).matches()) {
    etEmail.setError("Invalid email address");
    return;
}

if (phone.length() < 10) {
    etPhone.setError("Phone number must be at least 10 digits");
    return;
}

registerUser(email, phone);

public class MainApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();

        // Set up uncaught exception handler
        Thread.setDefaultUncaughtExceptionHandler((thread, throwable) -> {
            // Log crash
            FirebaseCrashlytics.getInstance().recordException(throwable);

            // Save app state
            saveAppState();

            // Show crash dialog (optional)
            Intent intent = new Intent(this, CrashActivity.class);
            intent.putExtra("error_message", throwable.getMessage());
            intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
            startActivity(intent);

            // Kill process
            android.os.Process.killProcess(android.os.Process.myPid());
            System.exit(10);
        });
    }
}

@Override
protected void onSaveInstanceState(Bundle outState) {
    super.onSaveInstanceState(outState);
    outState.putString("selected_date", selectedDate);
    outState.putParcelableArrayList("appointments", appointments);
}

@Override
protected void onRestoreInstanceState(Bundle savedInstanceState) {
    super.onRestoreInstanceState(savedInstanceState);
    selectedDate = savedInstanceState.getString("selected_date");
    appointments = savedInstanceState.getParcelableArrayList("appointments");
    refreshUI();
}

// Add custom keys for better crash context
FirebaseCrashlytics crashlytics = FirebaseCrashlytics.getInstance();
crashlytics.setCustomKey("user_id", userId);
crashlytics.setCustomKey("user_type", "care_provider");
crashlytics.setCustomKey("app_state", getCurrentState());

// Log non-fatal exceptions
try {
    processPayment();
} catch (PaymentException e) {
    crashlytics.recordException(e);
    showPaymentError();
}

// Add breadcrumbs
crashlytics.log("User navigated to appointments screen");
crashlytics.log("Loading appointments for date: " + date);

// Add Firebase Performance
dependencies {
    implementation 'com.google.firebase:firebase-perf:20.5.2'
}

// Track custom traces
Trace myTrace = FirebasePerformance.getInstance().newTrace("load_appointments");
myTrace.start();
loadAppointments();
myTrace.stop();

// Track network requests automatically (HTTP metrics)
// Enabled by default with firebase-perf

private void logError(String errorType, String errorMessage) {
    Bundle params = new Bundle();
    params.putString("error_type", errorType);
    params.putString("error_message", errorMessage);
    params.putString("screen_name", getCurrentScreenName());
    FirebaseAnalytics.getInstance(this).logEvent("app_error", params);
}

// Usage:
catch (NetworkException e) {
    logError("network_error", e.getMessage());
    showNetworkError();
}

// Add "Report Problem" button to error dialogs
AlertDialog.Builder builder = new AlertDialog.Builder(this);
builder.setTitle("Error Loading Appointments")
    .setMessage("We couldn't load your appointments. Please try again.")
    .setPositiveButton("Retry", (dialog, which) -> retryLoading())
    .setNeutralButton("Report Problem", (dialog, which) -> {
        // Collect crash logs and user description
        Intent intent = new Intent(this, ReportProblemActivity.class);
        intent.putExtra("error_log", getRecentLogs());
        intent.putExtra("screen_name", "Appointments");
        startActivity(intent);
    })
    .show();

// Use WorkManager for reliable background execution
public class SyncAppointmentWorker extends Worker {
    public SyncAppointmentWorker(@NonNull Context context, @NonNull WorkerParameters params) {
        super(context, params);
    }

    @NonNull
    @Override
    public Result doWork() {
        try {
            // Attempt to sync pending operations
            syncPendingAppointments();
            return Result.success();
        } catch (Exception e) {
            // Retry with exponential backoff
            return Result.retry();
        }
    }
}

// Queue work when offline
if (!isNetworkAvailable()) {
    Constraints constraints = new Constraints.Builder()
        .setRequiredNetworkType(NetworkType.CONNECTED)
        .build();

    OneTimeWorkRequest syncWork = new OneTimeWorkRequest.Builder(SyncAppointmentWorker.class)
        .setConstraints(constraints)
        .setBackoffCriteria(BackoffPolicy.EXPONENTIAL, 1, TimeUnit.MINUTES)
        .build();

    WorkManager.getInstance(context).enqueue(syncWork);
}

public class CollaborationMain extends Activity {
    private Handler handler = new Handler(); // Leaks Activity!

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        handler.postDelayed(runnable, 1000); // Scheduled task holds Activity reference
    }
}

┬───
│ GC Root: Thread
│
├─ android.os.HandlerThread
│    Leaking: NO (PathClassLoader↓ is not leaking)
│
├─ android.os.Handler
│    Leaking: UNKNOWN
│
╰→ com.psyter.www.CollaborationMain
     Leaking: YES (Activity destroyed but still in memory)
     10.5 MB retained

// Solution 1: Use static Handler with WeakReference
public class CollaborationMain extends Activity {
    private static class SafeHandler extends Handler {
        private final WeakReference<CollaborationMain> activityRef;

        SafeHandler(CollaborationMain activity) {
            this.activityRef = new WeakReference<>(activity);
        }

        @Override
        public void handleMessage(Message msg) {
            CollaborationMain activity = activityRef.get();
            if (activity != null && !activity.isFinishing()) {
                // Handle message
            }
        }
    }

    private final SafeHandler handler = new SafeHandler(this);

    @Override
    protected void onDestroy() {
        handler.removeCallbacksAndMessages(null); // Clear all pending messages
        super.onDestroy();
    }
}

// Solution 2: Use ViewModel with coroutines (better)
class CollaborationViewModel : ViewModel() {
    private val scope = viewModelScope

    fun scheduleTask() {
        scope.launch {
            delay(1000)
            // Automatically cancelled when ViewModel cleared
        }
    }
}

public class Utils {
    public static Activity currentActivity; // MEMORY LEAK!
    public static Context appContext; // OK if Application context
}

// Usage causes leak:
Utils.currentActivity = this; // Activity never released

// Never store Activity in static variable
public class Utils {
    // Store only Application context (safe)
    private static Application application;

    public static void init(Application app) {
        application = app;
    }

    // For Activity-specific operations, pass as parameter
    public static void showDialog(Activity activity, String message) {
        if (activity != null && !activity.isFinishing()) {
            // Use activity
        }
    }
}

Bitmap imageBitmap; // Class-level field holds large bitmap

// Loading without size constraints
imageBitmap = MediaStore.Images.Media.getBitmap(getContext().getContentResolver(), imageUri);
Bitmap _bmp = Bitmap.createScaledBitmap(imageBitmap, 256, 256, false);
imageBitmap = _bmp; // Original bitmap not recycled!
ivProfilePic.setImageBitmap(imageBitmap);

private Bitmap imageBitmap;

private void loadAndDisplayImage(Uri imageUri) {
    try {
        // Recycle old bitmap first
        if (imageBitmap != null && !imageBitmap.isRecycled()) {
            imageBitmap.recycle();
            imageBitmap = null;
        }

        // Load with size constraints using BitmapFactory.Options
        BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;
        BitmapFactory.decodeStream(
            getContext().getContentResolver().openInputStream(imageUri), 
            null, 
            options
        );

        // Calculate sample size
        options.inSampleSize = calculateInSampleSize(options, 256, 256);
        options.inJustDecodeBounds = false;

        // Load scaled bitmap directly
        imageBitmap = BitmapFactory.decodeStream(
            getContext().getContentResolver().openInputStream(imageUri),
            null,
            options
        );

        ivProfilePic.setImageBitmap(imageBitmap);

    } catch (OutOfMemoryError e) {
        Log.e(TAG, "OOM loading image", e);
        FirebaseCrashlytics.getInstance().recordException(e);
        showToast("Image too large");
    } catch (IOException e) {
        Log.e(TAG, "Error loading image", e);
    }
}

private int calculateInSampleSize(BitmapFactory.Options options, int reqWidth, int reqHeight) {
    int height = options.outHeight;
    int width = options.outWidth;
    int inSampleSize = 1;

    if (height > reqHeight || width > reqWidth) {
        int halfHeight = height / 2;
        int halfWidth = width / 2;

        while ((halfHeight / inSampleSize) >= reqHeight 
            && (halfWidth / inSampleSize) >= reqWidth) {
            inSampleSize *= 2;
        }
    }
    return inSampleSize;
}

@Override
public void onDestroyView() {
    // Clean up bitmap
    if (imageBitmap != null && !imageBitmap.isRecycled()) {
        imageBitmap.recycle();
        imageBitmap = null;
    }
    super.onDestroyView();
}

// Better: Use Glide instead
Glide.with(this)
    .load(imageUri)
    .override(256, 256)
    .centerCrop()
    .into(ivProfilePic);
// Glide handles memory management automatically

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    // Listener registered but never unregistered
    EventBus.getDefault().register(this);

    // BroadcastReceiver registered but never unregistered
    registerReceiver(networkReceiver, new IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION));
}

// onDestroy missing unregister calls!

private BroadcastReceiver networkReceiver;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    EventBus.getDefault().register(this);

    networkReceiver = new NetworkReceiver();
    registerReceiver(networkReceiver, 
        new IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION));
}

@Override
protected void onDestroy() {
    // Unregister all listeners
    EventBus.getDefault().unregister(this);

    if (networkReceiver != null) {
        unregisterReceiver(networkReceiver);
        networkReceiver = null;
    }

    super.onDestroy();
}

// Use Paging 3 library
class AppointmentPagingSource extends PagingSource<Integer, Appointment> {
    @Nullable
    @Override
    public Object load(@NotNull LoadParams<Integer> loadParams) {
        int page = loadParams.getKey() != null ? loadParams.getKey() : 0;

        // Load only current page (20 items)
        List<Appointment> appointments = repository.getAppointmentsPage(page, 20);

        return new LoadResult.Page<>(
            appointments,
            page == 0 ? null : page - 1,
            appointments.isEmpty() ? null : page + 1
        );
    }
}

// Adapter only holds visible items + buffer
class AppointmentAdapter extends PagingDataAdapter<Appointment, ViewHolder>(DIFF_CALLBACK) {
    // Automatically manages memory
}

// Configure Glide with memory and disk cache
@GlideModule
public class MyGlideModule extends AppGlideModule {
    @Override
    public void applyOptions(Context context, GlideBuilder builder) {
        // Memory cache: 20MB
        builder.setMemoryCache(new LruResourceCache(20 * 1024 * 1024));

        // Disk cache: 100MB
        builder.setDiskCache(new InternalCacheDiskCacheFactory(context, 100 * 1024 * 1024));

        // Bitmap pool: 30MB
        builder.setBitmapPool(new LruBitmapPool(30 * 1024 * 1024));
    }
}

// Usage with caching
Glide.with(context)
    .load(profileImageUrl)
    .diskCacheStrategy(DiskCacheStrategy.ALL) // Cache original & resized
    .placeholder(R.drawable.avatar_placeholder)
    .into(imageView);

String result = "";
for (int i = 0; i < array.length(); i++) {
    result += array.getString(i) + ", "; // Creates new String each iteration!
}

StringBuilder result = new StringBuilder();
for (int i = 0; i < array.length(); i++) {
    result.append(array.getString(i)).append(", ");
}
String finalResult = result.toString();

// Use Glide's bitmap pool
BitmapPool pool = Glide.get(context).getBitmapPool();
Bitmap bitmap = pool.get(width, height, Bitmap.Config.ARGB_8888);
// Use bitmap
pool.put(bitmap); // Return to pool when done

ArrayList<Appointment> list = new ArrayList<>(); // Default capacity: 10
// Adding 100 items causes multiple array resizing
for (int i = 0; i < 100; i++) {
    list.add(parseAppointment(i));
}

// Pre-allocate with known size
ArrayList<Appointment> list = new ArrayList<>(jsonArray.length());
for (int i = 0; i < jsonArray.length(); i++) {
    list.add(parseAppointment(i));
}

// Synchronous read of large JSON (100KB+)
String json = preferences.getString("appointments_data", "");
JSONArray array = new JSONArray(json); // Parsing 100KB JSON on main thread!

// Use Room with coroutines
@Dao
interface AppointmentDao {
    @Query("SELECT * FROM appointments")
    suspend fun getAllAppointments(): List<Appointment>
}

// Load in background
viewModelScope.launch {
    val appointments = withContext(Dispatchers.IO) {
        database.appointmentDao().getAllAppointments()
    }
    // Update UI on main thread
    updateUI(appointments)
}

// Saving bitmap synchronously
FileOutputStream fos = new FileOutputStream(file);
bitmap.compress(Bitmap.CompressFormat.JPEG, 90, fos);
fos.close(); // Blocks main thread!

}

public class MainApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();

        if (BuildConfig.DEBUG) {
            StrictMode.setThreadPolicy(new StrictMode.ThreadPolicy.Builder()
                .detectDiskReads()
                .detectDiskWrites()
                .detectNetwork()
                .penaltyLog()
                .penaltyFlashScreen() // Visual indicator
                .build());

            StrictMode.setVmPolicy(new StrictMode.VmPolicy.Builder()
                .detectLeakedSqlLiteObjects()
                .detectLeakedClosableObjects()
                .detectActivityLeaks()
                .penaltyLog()
                .build());
        }
    }
}

// Replace manual threading with WorkManager
public class SyncWorker extends Worker {
    public SyncWorker(@NonNull Context context, @NonNull WorkerParameters params) {
        super(context, params);
    }

    @NonNull
    @Override
    public Result doWork() {
        // Guaranteed background execution
        syncAppointments();
        return Result.success();
    }
}

// Schedule periodic sync
PeriodicWorkRequest syncWork = new PeriodicWorkRequest.Builder(
    SyncWorker.class, 
    15, 
    TimeUnit.MINUTES
)
.setConstraints(new Constraints.Builder()
    .setRequiredNetworkType(NetworkType.CONNECTED)
    .setRequiresBatteryNotLow(true)
    .build())
.build();

WorkManager.getInstance(context).enqueueUniquePeriodicWork(
    "sync_appointments",
    ExistingPeriodicWorkPolicy.KEEP,
    syncWork
);

for (int i = 0; i < jsonArray.length(); i++) {
    String value = dataArray.getString(i); // Crash if dataArray.length() < jsonArray.length()
}

for (int i = 0; i < Math.min(jsonArray.length(), dataArray.length()); i++) {
    String value = dataArray.getString(i);
}

// Or use safe access:
if (i < dataArray.length()) {
    String value = dataArray.getString(i);
}

Bundle extras = getIntent().getExtras();
ArrayList<String> items = (ArrayList<String>) extras.get("items"); // ClassCastException risk!

Bundle extras = getIntent().getExtras();
if (extras != null) {
    Object obj = extras.get("items");
    if (obj instanceof ArrayList) {
        @SuppressWarnings("unchecked")
        ArrayList<String> items = (ArrayList<String>) obj;
        // Safe to use
    } else {
        Log.w(TAG, "Unexpected type for items: " + (obj != null ? obj.getClass() : "null"));
    }
}

int resourceId = Resources.getSystem().getIdentifier("day", "id", "android");
View view = findViewById(resourceId); // May return 0, then crash

int resourceId = Resources.getSystem().getIdentifier("day", "id", "android");
if (resourceId != 0) {
    View view = findViewById(resourceId);
    if (view != null) {
        view.setVisibility(View.GONE);
    }
} else {
    Log.w(TAG, "Resource 'day' not found");
}