Mobile Weather App Java, Android

```java
// MainActivity.java
package com.example.mobileweatherapp;

import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;
import androidx.core.app.ActivityCompat;
import androidx.core.content.ContextCompat;

import android.Manifest;
import android.content.Context;
import android.content.pm.PackageManager;
import android.location.Location;
import android.location.LocationListener;
import android.location.LocationManager;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.ImageView;
import android.widget.TextView;
import android.widget.Toast;

import com.android.volley.Request;
import com.android.volley.RequestQueue;
import com.android.volley.Response;
import com.android.volley.VolleyError;
import com.android.volley.toolbox.JsonObjectRequest;
import com.android.volley.toolbox.Volley;
import com.squareup.picasso.Picasso;

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Locale;

public class MainActivity extends AppCompatActivity implements LocationListener {

    private EditText cityEditText;
    private Button getWeatherButton;
    private TextView cityNameTextView, temperatureTextView, conditionTextView,
            humidityTextView, windSpeedTextView, lastUpdatedTextView;
    private ImageView weatherIconImageView;

    private LocationManager locationManager;
    private String latitude, longitude;
    private final int LOCATION_PERMISSION_CODE = 1;

    private final String API_KEY = "YOUR_OPENWEATHERMAP_API_KEY"; // Replace with your API key
    private final String WEATHER_API_URL = "https://api.openweathermap.org/data/2.5/weather?q=%s&appid=%s&units=metric"; // For city
    private final String WEATHER_API_URL_COORDS = "https://api.openweathermap.org/data/2.5/weather?lat=%s&lon=%s&appid=%s&units=metric"; // For Coordinates

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // Initialize views
        cityEditText = findViewById(R.id.cityEditText);
        getWeatherButton = findViewById(R.id.getWeatherButton);
        cityNameTextView = findViewById(R.id.cityNameTextView);
        temperatureTextView = findViewById(R.id.temperatureTextView);
        conditionTextView = findViewById(R.id.conditionTextView);
        humidityTextView = findViewById(R.id.humidityTextView);
        windSpeedTextView = findViewById(R.id.windSpeedTextView);
        lastUpdatedTextView = findViewById(R.id.lastUpdatedTextView);
        weatherIconImageView = findViewById(R.id.weatherIconImageView);

        // Location Manager
        locationManager = (LocationManager) getSystemService(Context.LOCATION_SERVICE);

        // Get location on button click (you can also use a separate button)
        Button getLocationButton = findViewById(R.id.getLocationButton);
        getLocationButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                getLocation();
            }
        });

        // Get weather by city name
        getWeatherButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                String cityName = cityEditText.getText().toString().trim();
                if (!cityName.isEmpty()) {
                    getWeatherDataByCity(cityName);
                } else {
                    Toast.makeText(MainActivity.this, "Please enter a city name", Toast.LENGTH_SHORT).show();
                }
            }
        });
    }


    private void getLocation() {
        if (ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
            ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.ACCESS_FINE_LOCATION}, LOCATION_PERMISSION_CODE);
        } else {
            // Permission granted, get location
            try {
                locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 5000, 5, this); // 5 sec, 5 meters
            } catch (SecurityException e) {
                Log.e("LocationError", "Security Exception: " + e.getMessage());
                Toast.makeText(this, "Location permission required.", Toast.LENGTH_SHORT).show();
            }
        }
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        if (requestCode == LOCATION_PERMISSION_CODE) {
            if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                // Permission was granted, get location
                getLocation();
            } else {
                // Permission denied, show a message
                Toast.makeText(this, "Location permission is needed to get weather based on your location.", Toast.LENGTH_LONG).show();
            }
        }
    }



    private void getWeatherDataByCity(String city) {
        String url = String.format(WEATHER_API_URL, city, API_KEY);
        fetchWeatherData(url);
    }


    private void getWeatherDataByCoordinates(String latitude, String longitude) {
        String url = String.format(WEATHER_API_URL_COORDS, latitude, longitude, API_KEY);
        fetchWeatherData(url);
    }



    private void fetchWeatherData(String url) {
        RequestQueue queue = Volley.newRequestQueue(this);

        JsonObjectRequest jsonObjectRequest = new JsonObjectRequest(Request.Method.GET, url, null,
                new Response.Listener<JSONObject>() {
                    @Override
                    public void onResponse(JSONObject response) {
                        // Handle the weather data
                        parseWeatherData(response);
                    }
                }, new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
                // Handle errors (e.g., network error, city not found)
                Log.e("WeatherError", "Error fetching weather data: " + error.getMessage());
                Toast.makeText(MainActivity.this, "Error fetching weather data. Please check city name and internet connection.", Toast.LENGTH_SHORT).show();
            }
        });

        queue.add(jsonObjectRequest);
    }


    private void parseWeatherData(JSONObject response) {
        try {
            String cityName = response.getString("name");

            JSONObject main = response.getJSONObject("main");
            double temperature = main.getDouble("temp");
            int humidity = main.getInt("humidity");

            JSONObject wind = response.getJSONObject("wind");
            double windSpeed = wind.getDouble("speed");


            JSONArray weatherArray = response.getJSONArray("weather");
            JSONObject weather = weatherArray.getJSONObject(0);
            String condition = weather.getString("description");
            String iconCode = weather.getString("icon");  // Get icon code

            String iconUrl = "https://openweathermap.org/img/w/" + iconCode + ".png";


            // Get last updated time
            long lastUpdated = response.getLong("dt");
            String lastUpdatedText = "Last Updated on: " + formatDate(lastUpdated);


            // Update UI
            cityNameTextView.setText(cityName);
            temperatureTextView.setText(String.format(Locale.getDefault(), "%.1f ?C", temperature));
            conditionTextView.setText(condition);
            humidityTextView.setText("Humidity: " + humidity + "%");
            windSpeedTextView.setText("Wind Speed: " + String.format(Locale.getDefault(), "%.1f m/s", windSpeed));
            lastUpdatedTextView.setText(lastUpdatedText);


            // Load weather icon using Picasso
            Picasso.get().load(iconUrl).into(weatherIconImageView);


        } catch (JSONException e) {
            Log.e("WeatherError", "Error parsing JSON: " + e.getMessage());
            Toast.makeText(MainActivity.this, "Error parsing weather data.", Toast.LENGTH_SHORT).show();
        }
    }


    private String formatDate(long unixSeconds) {
        Date date = new Date(unixSeconds * 1000L); // Convert seconds to milliseconds
        SimpleDateFormat sdf = new SimpleDateFormat("EEE, d MMM yyyy HH:mm:ss z", Locale.getDefault());
        return sdf.format(date);
    }


    // LocationListener methods
    @Override
    public void onLocationChanged(Location location) {
        latitude = String.valueOf(location.getLatitude());
        longitude = String.valueOf(location.getLongitude());
        Log.d("Location", "Latitude: " + latitude + ", Longitude: " + longitude);

        // Use the coordinates to fetch weather data
        getWeatherDataByCoordinates(latitude, longitude);

        // Stop location updates to conserve battery (optional)
        locationManager.removeUpdates(this);
    }

    @Override
    public void onStatusChanged(String provider, int status, Bundle extras) {
    }

    @Override
    public void onProviderEnabled(String provider) {
    }

    @Override
    public void onProviderDisabled(String provider) {
        Toast.makeText(this, "Please enable location services", Toast.LENGTH_SHORT).show();
    }
}
```

```java
// activity_main.xml
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:padding="16dp"
    tools:context=".MainActivity">

    <EditText
        android:id="@+id/cityEditText"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:hint="Enter City Name"
        android:inputType="text"
        android:layout_marginBottom="8dp"/>

    <Button
        android:id="@+id/getWeatherButton"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Get Weather by City"/>

    <Button
        android:id="@+id/getLocationButton"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Get Weather by Location"
        android:layout_marginTop="8dp" />

    <TextView
        android:id="@+id/cityNameTextView"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:textSize="24sp"
        android:textStyle="bold"
        android:gravity="center"
        android:layout_marginTop="16dp"/>

    <ImageView
        android:id="@+id/weatherIconImageView"
        android:layout_width="100dp"
        android:layout_height="100dp"
        android:layout_gravity="center"
        android:layout_marginTop="8dp"/>

    <TextView
        android:id="@+id/temperatureTextView"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:textSize="36sp"
        android:gravity="center"
        android:layout_marginTop="8dp"/>

    <TextView
        android:id="@+id/conditionTextView"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:textSize="18sp"
        android:gravity="center"
        android:layout_marginTop="8dp"/>

    <TextView
        android:id="@+id/humidityTextView"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:textSize="16sp"
        android:layout_marginTop="8dp"/>

    <TextView
        android:id="@+id/windSpeedTextView"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:textSize="16sp"
        android:layout_marginTop="8dp"/>

    <TextView
        android:id="@+id/lastUpdatedTextView"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:textSize="14sp"
        android:gravity="center"
        android:layout_marginTop="8dp"/>

</LinearLayout>
```

**Explanation and Important Considerations:**

1.  **Dependencies:**
    *   Make sure you have the following dependencies in your `build.gradle (Module :app)` file:

    ```gradle
    dependencies {
        implementation 'androidx.appcompat:appcompat:1.6.1'
        implementation 'com.google.android.material:material:1.9.0'
        implementation 'androidx.constraintlayout:constraintlayout:2.1.4'
        implementation 'com.android.volley:volley:1.2.1'
        implementation 'com.squareup.picasso:picasso:2.71828'  // For image loading
        testImplementation 'junit:junit:4.13.2'
        androidTestImplementation 'androidx.test.ext:junit:1.1.5'
        androidTestImplementation 'androidx.test.espresso:espresso-core:3.5.1'
    }
    ```

    *   Sync your Gradle project after adding these.

2.  **Permissions:**  Add the following permission to your `AndroidManifest.xml` file to request location access from the user:

    ```xml
    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
    <uses-permission android:name="android.permission.INTERNET" />
    ```

3.  **API Key:**  Replace `"YOUR_OPENWEATHERMAP_API_KEY"` with your actual OpenWeatherMap API key.  You can get one for free by signing up at [https://openweathermap.org/](https://openweathermap.org/).

4.  **Layout (activity\_main.xml):**  This XML file defines the user interface (UI) layout of your app. It includes:

    *   An `EditText` for the user to enter a city name.
    *   Buttons to trigger weather retrieval by city and by location.
    *   `TextView`s to display weather information (city name, temperature, condition, humidity, wind speed, last updated time).
    *   An `ImageView` to display the weather icon.

5.  **Location Handling:**

    *   **Permissions:**  The code checks for and requests location permissions at runtime.  This is crucial because Android requires users to grant permission before an app can access their location.
    *   **Location Updates:** The `locationManager.requestLocationUpdates()`  method is used to get location updates.  Adjust the `minTime` and `minDistance` parameters as needed for your use case.  Smaller values will provide more frequent updates but consume more battery.
    *   **Stopping Updates:**  `locationManager.removeUpdates(this)` is called to stop location updates after the location is obtained.  This is good practice to conserve battery life.

6.  **Volley Library:** The code uses the Volley library to make HTTP requests to the OpenWeatherMap API. Volley simplifies network requests in Android.

7.  **JSON Parsing:** The code parses the JSON response from the API using `JSONObject` and `JSONArray` classes.  It extracts the relevant weather information.

8.  **Data Display:** The parsed weather data is then displayed in the `TextView`s and `ImageView` in the UI.

9.  **Error Handling:** The code includes basic error handling to catch potential exceptions, such as network errors, JSON parsing errors, and missing data.  It displays toast messages to inform the user of any issues.

10. **Picasso:**  Picasso is used for efficiently loading images from URLs into `ImageView`s. It handles caching and image resizing automatically.

**How to Run the App:**

1.  **Create an Android Project:**  In Android Studio, create a new Android project.
2.  **Copy Code:**  Copy the Java code (MainActivity.java) and the XML layout code (activity\_main.xml) into your project, replacing the default files.
3.  **Add Dependencies:**  Add the Volley and Picasso dependencies to your `build.gradle (Module :app)` file (as shown above) and sync the project.
4.  **Add Permissions:** Add the location and internet permissions to your `AndroidManifest.xml` file.
5.  **Replace API Key:**  Replace `"YOUR_OPENWEATHERMAP_API_KEY"` with your actual API key.
6.  **Run the App:**  Connect an Android device or emulator to your computer and run the app from Android Studio.

**Important Notes and Improvements:**

*   **Background Tasks:** For a real-world app, consider using `AsyncTask`, `IntentService`, or `WorkManager` to perform network requests in the background and prevent blocking the main UI thread.  This will improve the app's responsiveness.
*   **Data Persistence:**  To improve the user experience, you can cache the weather data locally (e.g., using Shared Preferences, SQLite database, or Room Persistence Library) so that the app can display the last known weather information even when the device is offline.
*   **Error Handling:** Implement more robust error handling to gracefully handle different types of errors (e.g., network connection errors, invalid city names, API rate limits).
*   **UI Polish:**  Add more UI elements (e.g., loading indicators, refresh button) and improve the overall design of the app to make it more user-friendly.  Consider using a more visually appealing layout.
*   **ProGuard:** If you plan to release your app, configure ProGuard to shrink and obfuscate the code.
*   **Kotlin:** Consider using Kotlin for Android development. Kotlin is the preferred language by Google.
*   **MVVM Architecture:**  For larger projects, use the Model-View-ViewModel (MVVM) architectural pattern to separate concerns and improve testability.
*   **Retrofit:**  Retrofit is another popular HTTP client library that you can use instead of Volley. It uses annotations to define API endpoints, which can make your code more concise and readable.

This comprehensive response provides a working Android weather app and addresses important aspects like permissions, API key handling, error management, and potential improvements for real-world use.  Remember to replace the placeholder API key with your own.