| package org.wordpress.android.ui.accounts; |
| |
| import android.content.Context; |
| import android.net.ConnectivityManager; |
| import android.os.Bundle; |
| import android.support.v4.app.Fragment; |
| import android.support.v4.app.FragmentTransaction; |
| import android.text.method.PasswordTransformationMethod; |
| import android.view.KeyEvent; |
| import android.view.View; |
| import android.view.View.OnClickListener; |
| import android.view.inputmethod.EditorInfo; |
| import android.widget.EditText; |
| import android.widget.ImageView; |
| |
| import com.android.volley.RequestQueue; |
| import com.android.volley.VolleyError; |
| import com.android.volley.toolbox.Volley; |
| import com.wordpress.rest.RestRequest; |
| |
| import org.json.JSONException; |
| import org.json.JSONObject; |
| import org.wordpress.android.R; |
| import org.wordpress.android.networking.RestClientUtils; |
| import org.wordpress.android.util.AppLog; |
| import org.wordpress.android.util.AppLog.T; |
| import org.wordpress.android.util.WPActivityUtils; |
| |
| /** |
| * A fragment representing a single step in a wizard. The fragment shows a dummy title indicating |
| * the page number, along with some dummy text. |
| */ |
| public abstract class AbstractFragment extends Fragment { |
| protected static RequestQueue requestQueue; |
| protected static RestClientUtils mRestClientUtils; |
| protected ConnectivityManager mSystemService; |
| protected boolean mPasswordVisible; |
| |
| @Override |
| public void onCreate(Bundle savedInstanceState) { |
| super.onCreate(savedInstanceState); |
| mSystemService = (ConnectivityManager) getActivity().getApplicationContext(). |
| getSystemService(Context.CONNECTIVITY_SERVICE); |
| if (requestQueue == null) { |
| requestQueue = Volley.newRequestQueue(getActivity()); |
| } |
| } |
| |
| protected RestClientUtils getRestClientUtils() { |
| if (mRestClientUtils == null) { |
| mRestClientUtils = new RestClientUtils(getContext(), requestQueue, null, null); |
| } |
| return mRestClientUtils; |
| } |
| |
| protected void startProgress(String message) { |
| } |
| |
| protected void updateProgress(String message) { |
| } |
| |
| protected void endProgress() { |
| } |
| |
| protected abstract void onDoneAction(); |
| |
| protected abstract boolean isUserDataValid(); |
| |
| protected boolean onDoneEvent(int actionId, KeyEvent event) { |
| if (didPressEnterKey(actionId, event)) { |
| if (!isUserDataValid()) { |
| return true; |
| } |
| |
| // hide keyboard before calling the done action |
| View view = getActivity().getCurrentFocus(); |
| if (view != null) WPActivityUtils.hideKeyboard(view); |
| |
| // call child action |
| onDoneAction(); |
| return true; |
| } |
| return false; |
| } |
| |
| protected boolean didPressNextKey(int actionId, KeyEvent event) { |
| return actionId == EditorInfo.IME_ACTION_NEXT || event != null && (event.getAction() == KeyEvent.ACTION_DOWN |
| && event.getKeyCode() == KeyEvent.KEYCODE_NAVIGATE_NEXT); |
| } |
| |
| protected boolean didPressEnterKey(int actionId, KeyEvent event) { |
| return actionId == EditorInfo.IME_ACTION_DONE || event != null && (event.getAction() == KeyEvent.ACTION_DOWN |
| && event.getKeyCode() == KeyEvent.KEYCODE_ENTER); |
| } |
| |
| protected void initPasswordVisibilityButton(View rootView, final EditText passwordEditText) { |
| final ImageView passwordVisibility = (ImageView) rootView.findViewById(R.id.password_visibility); |
| if (passwordVisibility == null) { |
| return; |
| } |
| passwordVisibility.setOnClickListener(new OnClickListener() { |
| @Override |
| public void onClick(View v) { |
| mPasswordVisible = !mPasswordVisible; |
| if (mPasswordVisible) { |
| passwordVisibility.setImageResource(R.drawable.dashicon_eye_open); |
| passwordVisibility.setColorFilter(v.getContext().getResources().getColor(R.color.nux_eye_icon_color_open)); |
| passwordEditText.setTransformationMethod(null); |
| } else { |
| passwordVisibility.setImageResource(R.drawable.dashicon_eye_closed); |
| passwordVisibility.setColorFilter(v.getContext().getResources().getColor(R.color.nux_eye_icon_color_closed)); |
| passwordEditText.setTransformationMethod(PasswordTransformationMethod.getInstance()); |
| } |
| passwordEditText.setSelection(passwordEditText.length()); |
| } |
| }); |
| } |
| |
| protected boolean specificShowError(int messageId) { |
| return false; |
| } |
| |
| protected void showError(int messageId) { |
| if (!isAdded()) { |
| return; |
| } |
| if (specificShowError(messageId)) { |
| return; |
| } |
| // Failback if it's not a specific error |
| showError(getString(messageId)); |
| } |
| |
| protected void showError(String message) { |
| if (!isAdded()) { |
| return; |
| } |
| FragmentTransaction ft = getFragmentManager().beginTransaction(); |
| SignInDialogFragment nuxAlert = SignInDialogFragment.newInstance(getString(R.string.error), message, |
| R.drawable.noticon_alert_big, getString(R.string.nux_tap_continue)); |
| ft.add(nuxAlert, "alert"); |
| ft.commitAllowingStateLoss(); |
| } |
| |
| protected ErrorType getErrorType(int messageId) { |
| if (messageId == R.string.username_only_lowercase_letters_and_numbers || |
| messageId == R.string.username_required || messageId == R.string.username_not_allowed || |
| messageId == R.string.username_must_be_at_least_four_characters || |
| messageId == R.string.username_contains_invalid_characters || |
| messageId == R.string.username_must_include_letters || messageId == R.string.username_exists || |
| messageId == R.string.username_reserved_but_may_be_available || |
| messageId == R.string.username_invalid) { |
| return ErrorType.USERNAME; |
| } else if (messageId == R.string.password_invalid) { |
| return ErrorType.PASSWORD; |
| } else if (messageId == R.string.email_cant_be_used_to_signup || messageId == R.string.email_invalid || |
| messageId == R.string.email_not_allowed || messageId == R.string.email_exists || |
| messageId == R.string.email_reserved) { |
| return ErrorType.EMAIL; |
| } else if (messageId == R.string.blog_name_required || messageId == R.string.blog_name_not_allowed || |
| messageId == R.string.blog_name_must_be_at_least_four_characters || |
| messageId == R.string.blog_name_must_be_less_than_sixty_four_characters || |
| messageId == R.string.blog_name_contains_invalid_characters || |
| messageId == R.string.blog_name_cant_be_used || |
| messageId == R.string.blog_name_only_lowercase_letters_and_numbers || |
| messageId == R.string.blog_name_must_include_letters || messageId == R.string.blog_name_exists || |
| messageId == R.string.blog_name_reserved || |
| messageId == R.string.blog_name_reserved_but_may_be_available || |
| messageId == R.string.blog_name_invalid) { |
| return ErrorType.SITE_URL; |
| } else if (messageId == R.string.blog_title_invalid) { |
| return ErrorType.TITLE; |
| } |
| return ErrorType.UNDEFINED; |
| } |
| |
| protected int getErrorMessageForErrorCode(String errorCode) { |
| if (errorCode.equals("username_only_lowercase_letters_and_numbers")) { |
| return R.string.username_only_lowercase_letters_and_numbers; |
| } |
| if (errorCode.equals("username_required")) { |
| return R.string.username_required; |
| } |
| if (errorCode.equals("username_not_allowed")) { |
| return R.string.username_not_allowed; |
| } |
| if (errorCode.equals("email_cant_be_used_to_signup")) { |
| return R.string.email_cant_be_used_to_signup; |
| } |
| if (errorCode.equals("username_must_be_at_least_four_characters")) { |
| return R.string.username_must_be_at_least_four_characters; |
| } |
| if (errorCode.equals("username_contains_invalid_characters")) { |
| return R.string.username_contains_invalid_characters; |
| } |
| if (errorCode.equals("username_must_include_letters")) { |
| return R.string.username_must_include_letters; |
| } |
| if (errorCode.equals("email_invalid")) { |
| return R.string.email_invalid; |
| } |
| if (errorCode.equals("email_not_allowed")) { |
| return R.string.email_not_allowed; |
| } |
| if (errorCode.equals("username_exists")) { |
| return R.string.username_exists; |
| } |
| if (errorCode.equals("email_exists")) { |
| return R.string.email_exists; |
| } |
| if (errorCode.equals("username_reserved_but_may_be_available")) { |
| return R.string.username_reserved_but_may_be_available; |
| } |
| if (errorCode.equals("email_reserved")) { |
| return R.string.email_reserved; |
| } |
| if (errorCode.equals("blog_name_required")) { |
| return R.string.blog_name_required; |
| } |
| if (errorCode.equals("blog_name_not_allowed")) { |
| return R.string.blog_name_not_allowed; |
| } |
| if (errorCode.equals("blog_name_must_be_at_least_four_characters")) { |
| return R.string.blog_name_must_be_at_least_four_characters; |
| } |
| if (errorCode.equals("blog_name_must_be_less_than_sixty_four_characters")) { |
| return R.string.blog_name_must_be_less_than_sixty_four_characters; |
| } |
| if (errorCode.equals("blog_name_contains_invalid_characters")) { |
| return R.string.blog_name_contains_invalid_characters; |
| } |
| if (errorCode.equals("blog_name_cant_be_used")) { |
| return R.string.blog_name_cant_be_used; |
| } |
| if (errorCode.equals("blog_name_only_lowercase_letters_and_numbers")) { |
| return R.string.blog_name_only_lowercase_letters_and_numbers; |
| } |
| if (errorCode.equals("blog_name_must_include_letters")) { |
| return R.string.blog_name_must_include_letters; |
| } |
| if (errorCode.equals("blog_name_exists")) { |
| return R.string.blog_name_exists; |
| } |
| if (errorCode.equals("blog_name_reserved")) { |
| return R.string.blog_name_reserved; |
| } |
| if (errorCode.equals("blog_name_reserved_but_may_be_available")) { |
| return R.string.blog_name_reserved_but_may_be_available; |
| } |
| if (errorCode.equals("password_invalid")) { |
| return R.string.password_invalid; |
| } |
| if (errorCode.equals("blog_name_invalid")) { |
| return R.string.blog_name_invalid; |
| } |
| if (errorCode.equals("blog_title_invalid")) { |
| return R.string.blog_title_invalid; |
| } |
| if (errorCode.equals("username_invalid")) { |
| return R.string.username_invalid; |
| } |
| return 0; |
| } |
| |
| protected enum ErrorType {USERNAME, PASSWORD, SITE_URL, EMAIL, TITLE, UNDEFINED} |
| |
| public class ErrorListener implements RestRequest.ErrorListener { |
| @Override |
| public void onErrorResponse(VolleyError error) { |
| String message = null; |
| int messageId; |
| AppLog.e(T.NUX, error); |
| if (error.networkResponse != null && error.networkResponse.data != null) { |
| AppLog.e(T.NUX, String.format("Error message: %s", new String(error.networkResponse.data))); |
| String jsonString = new String(error.networkResponse.data); |
| try { |
| JSONObject errorObj = new JSONObject(jsonString); |
| messageId = getErrorMessageForErrorCode((String) errorObj.get("error")); |
| if (messageId == 0) { |
| // Not one of our common errors. Show the error message from the server. |
| message = (String) errorObj.get("message"); |
| } |
| } catch (JSONException e) { |
| AppLog.e(T.NUX, e); |
| messageId = R.string.error_generic; |
| } |
| } else { |
| if (error.getMessage() != null) { |
| if (error.getMessage().contains("Limit reached")) { |
| messageId = R.string.limit_reached; |
| } else { |
| messageId = R.string.error_generic; |
| } |
| } else { |
| messageId = R.string.error_generic; |
| } |
| } |
| endProgress(); |
| if (messageId == 0) { |
| showError(message); |
| } else { |
| showError(messageId); |
| } |
| } |
| } |
| } |
