Android Open Source - opentraining Upload Exercise Async Task

• Back to App/fitness  ↑

From Project

Back to project page opentraining.

License

The source code is released under:

GNU General Public License

Java Source Code

/**
 * //w w w.  j  av a  2s  .  c o m
 * This is OpenTraining, an Android application for planning your your fitness training.
 * Copyright (C) 2012-2014 Christian Skubich
 * 
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 * 
 */

package de.skubware.opentraining.activity.create_workout.upload_exercise;

import java.io.UnsupportedEncodingException;
import java.util.Locale;
import java.util.Map;

import retrofit.RequestInterceptor;
import retrofit.RestAdapter;
import retrofit.RetrofitError;
import retrofit.RequestInterceptor.RequestFacade;
import retrofit.RestAdapter.LogLevel;
import retrofit.android.AndroidLog;
import retrofit.client.Response;
import retrofit.converter.GsonConverter;
import retrofit.mime.MimeUtil;
import retrofit.mime.TypedByteArray;
import retrofit.mime.TypedInput;
import android.app.AlertDialog;
import android.app.ProgressDialog;
import android.content.Context;
import android.content.SharedPreferences;
import android.os.AsyncTask;
import android.preference.PreferenceManager;
import android.util.Log;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonSerializer;

import de.skubware.opentraining.BuildConfig;
import de.skubware.opentraining.R;
import de.skubware.opentraining.activity.create_workout.ExerciseTypeDetailFragment;
import de.skubware.opentraining.basic.ExerciseType;
import de.skubware.opentraining.basic.Muscle;
import de.skubware.opentraining.basic.SportsEquipment;
import de.skubware.opentraining.db.rest.ExerciseImageGSONSerializer;
import de.skubware.opentraining.db.rest.ExerciseTypeGSONSerializer;
import de.skubware.opentraining.db.rest.LanguageGSONDeserializer;
import de.skubware.opentraining.db.rest.MuscleGSONDeserializer;
import de.skubware.opentraining.db.rest.ServerModel;
import de.skubware.opentraining.db.rest.SportsEquipmentGSONDeserializer;
import de.skubware.opentraining.db.rest.ServerModel.Equipment;
import de.skubware.opentraining.db.rest.ServerModel.Language;
import de.skubware.opentraining.db.rest.ServerModel.MuscleCategory;

public class UploadExerciseAsyncTask extends AsyncTask<ExerciseType, Void, Throwable> {
  private final Context mContext;
  private final ProgressDialog mDialog;


  /**
   * @param exerciseTypeDetailFragment
   */
  public UploadExerciseAsyncTask(Context context) {
    mContext = context;
    mDialog = new ProgressDialog(mContext);
  }


    
    
    protected void onPreExecute() {
         this.mDialog.setMessage("Uploading exercise ...");
         this.mDialog.show();
      }
    
  
  /**
   * @return Null if everything went fine, the original exception otherwise.
   */
  @Override
  protected Throwable doInBackground(ExerciseType... exercise) {

    RestAdapter restAdapter = getRestAdapter(mContext, new ExerciseTypeGSONSerializer());

    WgerRestService service = restAdapter.create(WgerRestService.class);

    // get server model of SportsEquipment
    ServerModel.Equipment[] serverEquipment = service.getEquipment();
    Map<SportsEquipment, Equipment> eqMap = Equipment.getEquipmentMap(serverEquipment, mContext);
    ExerciseTypeGSONSerializer.setEquipmentMap(eqMap);

    // get server model of Muscle(categories)
    ServerModel.MuscleCategory[] serverMuscles = service.getMuscles();
    Map<Muscle, MuscleCategory> muscleMap = MuscleCategory.getMuscleMap(serverMuscles, mContext);
    ExerciseTypeGSONSerializer.setMuscleMap(muscleMap);

    for (Muscle m : muscleMap.keySet()) {
      Log.e(ExerciseTypeDetailFragment.TAG, m.toString() + " = " + muscleMap.get(m) + "\n");
    }

    // get server model of Languages
    ServerModel.Language[] serverLanguages = service.getLanguages();
    Map<Locale, Language> languageMap = Language.getLanguageMap(serverLanguages, mContext);
    ExerciseTypeGSONSerializer.setLanguageMap(languageMap);

    try {
      service.createExercise(exercise[0]);    
    } catch (RetrofitError retEr) {
      if(retEr.getCause() != null)
        return retEr.getCause();
      else
        return retEr;
    }
    
    return null;
  }

  @Override
  protected void onPostExecute(Throwable ex) {
    mDialog.dismiss();

    AlertDialog.Builder alertDialog = new AlertDialog.Builder(mContext);
    String msg;
    String title;
    if (ex == null) {
      // everything went fine
      title = "Upload successfull";
      msg = "Upload finished";
    } else {
      title = "Upload failed";
      if(ex instanceof RetrofitError){
        // show server response to user
        Response response = ((RetrofitError) ex).getResponse();
        msg = response.getReason() + ": " + getBodyString(response);
      }else{
        // show custom error message if problem is known
        msg = ex.getMessage();
      }  
    }
    alertDialog.setMessage(msg);
    alertDialog.setTitle(title);
    alertDialog.create().show();
  }

  @Override
  protected void onProgressUpdate(Void... values) {
  }
  
  
  /* Helper method for parsing the response body */
  public static String getBodyString(Response response) {

    TypedInput body = response.getBody();

    if (body != null) {

      if (!(body instanceof TypedByteArray)) {
        Log.e(ExerciseTypeDetailFragment.TAG, "Could not parse.");
        return "";
      }

      byte[] bodyBytes = ((TypedByteArray) body).getBytes();
      String bodyMime = body.mimeType();
      String bodyCharset = MimeUtil.parseCharset(bodyMime);
      try {
        return new String(bodyBytes, bodyCharset);
      } catch (UnsupportedEncodingException e) {
        Log.e(ExerciseTypeDetailFragment.TAG, "Could not parse.");
        return "";
      }
    }
    return null;

  }
  
  public static RestAdapter getRestAdapter(Context c, JsonSerializer serializer){
    GsonBuilder gsonBuilder = new GsonBuilder();
    gsonBuilder.registerTypeAdapter(ExerciseType.class, serializer);
    gsonBuilder.setPrettyPrinting();

    Gson gson = gsonBuilder.create();

    GsonConverter converter = new GsonConverter(gson);

    RestAdapter.Builder builder = new RestAdapter.Builder().setConverter(converter).setRequestInterceptor(new RequestInterceptor() {
      @Override
      public void intercept(RequestFacade requestFacade) {
        requestFacade.addHeader("Authorization", "Token ba1ce753f54ba3b8ee4af301f07c58628a1c01bf");
      }
    });

    String baseURL;
    if (BuildConfig.DEBUG) {
      // set different API-Endpoint for debugging
      baseURL = "http://preview.wger.de";
      // only log if debug-build
      // (otherwise auth-token appears in log)
      builder.setLog(new AndroidLog("WgerRestService")).setLogLevel(LogLevel.FULL);
    } else {
      // get the URL from preferences
      SharedPreferences settings = PreferenceManager.getDefaultSharedPreferences(c);
      baseURL = settings.getString("exercise_sync_url",
          c.getString(R.string.pref_default_exercise_sync_url));
    }
    builder.setEndpoint(baseURL + "/api/v2/");
    
    return builder.build();
  }
  
}

Java Source Code List

• Back to App/fitness  ↑