title: Cannot find symbol getActivity()?
body: <p>I am learning android from Udacity's course on developing Android apps.</p>
  
  <p>In that they show us how to develop weather app, but I am stuck in the code where we add the code for changing the temperature units.</p>
  
  <p>My question is why can't i use <strong>getActivity()</strong> method in following code:</p>
  
  <p><strong>Its in the first line of the very first function</strong>.</p>
  
  <pre><code>class FetchWeatherTask extends AsyncTask&lt;String ,Void,String []&gt;
  {    
   public String formatHighLows(double high, double low) {
          SharedPreferences sharedPrefs=PreferenceManager.getDefaultSharedPreferences(getActivity());
          String unitType=sharedPrefs.getString(getString(R.string.pref_units_key),getString(R.string.pref_units_metric));
          if(unitType.equals(getString(R.string.pref_units_imperial)))
          {
              high=(high*1.8)+32;
              low=(low*1.8)+32;
          }
          else if(!unitType.equals(getString(R.string.pref_units_metric)))
          {
              Toast.makeText(getActivity(),"invalid unit",Toast.LENGTH_SHORT).show();
          }
          long roundedHigh = Math.round(high);
          long roundedLow = Math.round(low);
          String str= roundedHigh+"/"+roundedLow;
          return str;
  
      }
      @Override
      protected String [] doInBackground(String []params)
  
      {  HttpURLConnection urlConnection = null;
          BufferedReader reader = null;
  
          // Will contain the raw JSON response as a string.
          String forecastJsonStr = null;
          String format="json";
          String units="metric";
          int numDays=7;
          try {
  
              final String FORECAST_BASE_URL="http://api.openweathermap.org/data/2.5/forecast/daily?";
              final String QUERY_PARAM="q";
              final String FORMAT_PARAM="mode";
              final String UNITS_PARAM="units";
              final String DAYS_PARAM="cnt";
              Uri builtUri=Uri.parse(FORECAST_BASE_URL).buildUpon()
                      .appendQueryParameter(QUERY_PARAM,params[0])
                      .appendQueryParameter(FORMAT_PARAM,format)
                      .appendQueryParameter(UNITS_PARAM,units)
                      .appendQueryParameter(DAYS_PARAM,Integer.toString(numDays))
                      .build();
              URL url = new URL(builtUri.toString());         
              http://api.openweathermap.org/data/2.5/forecast/daily?q=94043&amp;mode=json&amp;units=metric&amp;cnt=7
              urlConnection = (HttpURLConnection) url.openConnection();
              urlConnection.setRequestMethod("GET");
              urlConnection.connect();
  
              // Read the input stream into a String
              InputStream inputStream = urlConnection.getInputStream();
              StringBuffer buffer = new StringBuffer();
              if (inputStream == null) {
                  // Nothing to do.
                  return null;
              }
              reader = new BufferedReader(new InputStreamReader(inputStream));
  
              String line;
              while ((line = reader.readLine()) != null) {
                  // Since it's JSON, adding a newline isn't necessary (it won't affect parsing)
                  // But it does make debugging a *lot* easier if you print out the completed
                  // buffer for debugging.
                  buffer.append(line + "\n");
              }
  
              if (buffer.length() == 0) {
                  // Stream was empty.  No point in parsing.
                  return null;
              }
              forecastJsonStr = buffer.toString();
          } catch (IOException e) {
              Log.e("PlaceholderFragment", "Error ", e);
              // If the code didn't successfully get the weather data, there's no point in attemping
              // to parse it.
              return null;
          } finally{
              if (urlConnection != null) {
                  urlConnection.disconnect();
              }
              if (reader != null) {
                  try {
                      reader.close();
                  } catch (final IOException e) {
                      Log.e("PlaceholderFragment", "Error closing stream", e);
                  }
              }
          }
  
          try
          {
              return getWeatherDataFromJson(forecastJsonStr,numDays);
          }
          catch(JSONException e)
          {
  
          }
          return null;
      }
      protected void onPostExecute(String[] result) {
          /*RECEIVES THE STRING ARRAY FROM THE DOINBACKGROUND METHOD. THE RESULT IS BY DEFAULT RETURNED TO THE ONPOST EXECUTE
          * AND WE CAN ACCESS THE ARRAYLIST OF WEATHER WHICH POPULATES THE LISTVIEW BECAUSE WE HAVE MADE THAT STATIC.*/
          if (result != null) {
              MainActivityFragment.weather_adapter.clear();
              for(String dayForecastStr : result) {
                  MainActivityFragment.weather_adapter.add(dayForecastStr);
              }
              // New data is back from the server.  Hooray!
          }
      }
      private String getReadableDateString(long time){
          // Because the API returns a unix timestamp (measured in seconds),
          // it must be converted to milliseconds in order to be converted to valid date.
          SimpleDateFormat shortenedDateFormat = new SimpleDateFormat("EEE MMM dd");
          return shortenedDateFormat.format(time);
      }
  
      /**
       * Prepare the weather high/lows for presentation.
       */
  
  
      /**
       * Take the String representing the complete forecast in JSON Format and
       * pull out the data we need to construct the Strings needed for the wireframes.
       *
       * Fortunately parsing is easy:  constructor takes the JSON string and converts it
       * into an Object hierarchy for us.
       */
      private String[] getWeatherDataFromJson(String forecastJsonStr, int numDays)
              throws JSONException
  
      {
          // These are the names of the JSON objects that need to be extracted.
          final String OWM_LIST = "list";/*it will contain the weather data for seven days, it is an array*/
          /*every element of the list has a one element long array called weather which contains weather details of corresponding
          day.
           */
          final String OWM_WEATHER = "weather";
          final String OWM_TEMPERATURE = "temp";
          final String OWM_MAX = "max";
          final String OWM_MIN = "min";
          final String OWM_DESCRIPTION = "main";/*this will contain the weather description main title like clear
  
          /*The json object is created from the string which contains data in json format*/
          JSONObject forecastJson = new JSONObject(forecastJsonStr);
          JSONArray weatherArray = forecastJson.getJSONArray(OWM_LIST);
  
          // OWM returns daily forecasts based upon the local time of the city that is being
          // asked for, which means that we need to know the GMT offset to translate this data
          // properly.
  
          // Since this data is also sent in-order and the first day is always the
          // current day, we're going to take advantage of that to get a nice
          // normalized UTC date for all of our weather.
          // We are doing this because we have to associate date with each forecast entry.
  
          Time dayTime = new Time();
          dayTime.setToNow();
  
          // we start at the day returned by local time. Otherwise this is a mess.
          // julian day returns the number of days that have passed since the julian period.
          int julianStartDay = Time.getJulianDay(System.currentTimeMillis(), dayTime.gmtoff);
  
          // now we work exclusively in UTC
          dayTime = new Time();
  
          String[] resultStrs = new String[numDays];
          for(int i = 0; i &lt; weatherArray.length(); i++) {
              // For now, using the format "Day, description, hi/low"
              String day;
              String description;
              String highAndLow;
  
              // Get the JSON object representing the day
              JSONObject dayForecast = weatherArray.getJSONObject(i);
  
              // The date/time is returned as a long.  We need to convert that
              // into something human-readable, since most people won't read "1400356800" as
              // "this saturday".
              long dateTime;
              // Cheating to convert this to UTC time, which is what we want anyhow
              dateTime = dayTime.setJulianDay(julianStartDay+i);
              day = getReadableDateString(dateTime);
  
              // description is in a child array called "weather", which is 1 element long.it contains the description of the
              /*weather for the corresponding day in the form of string*/
              /*weatherObject is the corresponding object of the ith day*/
              JSONObject weatherObject = dayForecast.getJSONArray(OWM_WEATHER).getJSONObject(0);
              /*OWM_DESCRIPTION contains the "main" description like clear*/
              description = weatherObject.getString(OWM_DESCRIPTION);
  
              // Temperatures are in a child object called "temp".It contains the max and min temperatures
              // in double format with the keys mentioned OWM_MAX and OWM_MIN Try not to name variables
              // "temp" when working with temperature.  It confuses everybody.
              JSONObject temperatureObject = dayForecast.getJSONObject(OWM_TEMPERATURE);
              double high = temperatureObject.getDouble(OWM_MAX);
              double low = temperatureObject.getDouble(OWM_MIN);
  
              resultStrs[i] = day + " - " + description + " - " +Math.round(high)+" / "+Math.round(low);
  
          }
          return resultStrs;
      }
  
  }
  </code></pre>