27 | * Otto infers the instance type from the annotated method's return type. Producer methods may return null when there is
28 | * no appropriate value to share. The calling {@link Bus} ignores such returns and posts nothing.
29 | *
30 | * @author Jake Wharton
31 | */
32 | @Retention(RetentionPolicy.RUNTIME)
33 | @Target(ElementType.METHOD)
34 | public @interface Produce {
35 | }
36 |
--------------------------------------------------------------------------------
/AndroidManifest.xml:
--------------------------------------------------------------------------------
1 |
2 | Subscribing a DeadEvent handler is useful for debugging or logging, as it can detect misconfigurations in a
23 | * system's event distribution.
24 | *
25 | * @author Cliff Biffle
26 | */
27 | public class DeadEvent {
28 |
29 | public final Object source;
30 | public final Object event;
31 |
32 | /**
33 | * Creates a new DeadEvent.
34 | *
35 | * @param source object broadcasting the DeadEvent (generally the {@link Bus}).
36 | * @param event the event that could not be delivered.
37 | */
38 | public DeadEvent(Object source, Object event) {
39 | this.source = source;
40 | this.event = event;
41 | }
42 |
43 | }
44 |
--------------------------------------------------------------------------------
/src/com/squareup/otto/Subscribe.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2007 The Guava Authors
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.squareup.otto;
18 |
19 | import java.lang.annotation.ElementType;
20 | import java.lang.annotation.Retention;
21 | import java.lang.annotation.RetentionPolicy;
22 | import java.lang.annotation.Target;
23 |
24 | /**
25 | * Marks a method as an event handler, as used by {@link AnnotatedHandlerFinder} and {@link Bus}.
26 | *
27 | * The method's first (and only) parameter defines the event type.
28 | * If this annotation is applied to methods with zero parameters or more than one parameter, the object containing
29 | * the method will not be able to register for event delivery from the {@link Bus}. Otto fails fast by throwing
30 | * runtime exceptions in these cases.
31 | *
32 | * @author Cliff Biffle
33 | */
34 | @Retention(RetentionPolicy.RUNTIME)
35 | @Target(ElementType.METHOD)
36 | public @interface Subscribe {
37 | }
38 |
--------------------------------------------------------------------------------
/src/com/keyconsultant/parse/logintutorial/activity/StatusView.java:
--------------------------------------------------------------------------------
1 | package com.keyconsultant.parse.logintutorial.activity;
2 |
3 | import com.keyconsultant.parse.logintutorial.R;
4 |
5 | import android.content.Context;
6 | import android.util.AttributeSet;
7 | import android.view.LayoutInflater;
8 | import android.widget.LinearLayout;
9 | import android.widget.TextView;
10 |
11 | /**
12 | * Loading view with nondeterminate spinner
13 | *
14 | * @author Trey Robinson
15 | *
16 | */
17 | public class StatusView extends LinearLayout {
18 |
19 | private TextView mStatusMessage;
20 |
21 | public StatusView(Context context) {
22 | super(context);
23 | initViews(context);
24 | }
25 |
26 | public StatusView(Context context, AttributeSet attrs) {
27 | super(context, attrs);
28 | initViews(context);
29 | }
30 |
31 | public StatusView(Context context, AttributeSet attrs, int defStyle) {
32 | super(context, attrs, defStyle);
33 | initViews(context);
34 | }
35 |
36 | private void initViews(Context context){
37 |
38 | LayoutInflater inflater = (LayoutInflater)context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
39 | inflater.inflate(R.layout.view_status, this, true);
40 | mStatusMessage = (TextView)findViewById(R.id.status_message);
41 | }
42 |
43 | /**
44 | * Set the message to display on the loading screen.
45 | * @param statusMessage
46 | * Message to display on the loading screen
47 | */
48 | public void setStatusMessage(String statusMessage){
49 | mStatusMessage.setText(statusMessage);
50 | }
51 |
52 | }
53 |
--------------------------------------------------------------------------------
/src/com/keyconsultant/parse/logintutorial/forgotpassword/ForgotPasswordDialogFragment.java:
--------------------------------------------------------------------------------
1 | package com.keyconsultant.parse.logintutorial.forgotpassword;
2 |
3 | import com.keyconsultant.parse.logintutorial.R;
4 | import com.keyconsultant.parse.logintutorial.model.user.UserManager;
5 |
6 | import android.os.Bundle;
7 | import android.support.v4.app.DialogFragment;
8 | import android.view.LayoutInflater;
9 | import android.view.View;
10 | import android.view.View.OnClickListener;
11 | import android.view.ViewGroup;
12 | import android.widget.EditText;
13 |
14 | /**
15 | * Simple dialog for entering the email for a forgotten password.
16 | *
17 | * @author Trey Robinson
18 | *
19 | */
20 | public class ForgotPasswordDialogFragment extends DialogFragment implements OnClickListener{
21 | private EditText mEmailEditText;
22 |
23 | public ForgotPasswordDialogFragment (){
24 |
25 | }
26 |
27 | @Override
28 | public View onCreateView(LayoutInflater inflater, ViewGroup container,
29 | Bundle savedInstanceState) {
30 | View view = inflater.inflate(R.layout.dialog_forgot_password, container);
31 | mEmailEditText = (EditText) view.findViewById(R.id.etEmail);
32 | view.findViewById(R.id.submitButton).setOnClickListener(this);
33 |
34 |
35 | getDialog().setTitle("Enter Email Below.");
36 |
37 | return view;
38 | }
39 |
40 | @Override
41 | public void onClick(View v) {
42 | switch (v.getId()) {
43 | case R.id.submitButton:
44 | submitForgotPassword();
45 | break;
46 | default:
47 | break;
48 | }
49 | }
50 |
51 | private void submitForgotPassword(){
52 |
53 |
54 | UserManager.getInstance().forgotPassword(mEmailEditText.getText().toString());
55 | this.dismiss();
56 | }
57 | }
58 |
--------------------------------------------------------------------------------
/src/com/squareup/otto/ThreadEnforcer.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2012 Square, Inc.
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.squareup.otto;
18 |
19 | import android.os.Looper;
20 |
21 | /**
22 | * Enforces a thread confinement policy for methods on a particular event bus.
23 | *
24 | * @author Jake Wharton
25 | */
26 | public interface ThreadEnforcer {
27 |
28 | /**
29 | * Enforce a valid thread for the given {@code bus}. Implementations may throw any runtime exception.
30 | *
31 | * @param bus Event bus instance on which an action is being performed.
32 | */
33 | void enforce(Bus bus);
34 |
35 |
36 | /** A {@link ThreadEnforcer} that does no verification or enforcement for any action. */
37 | ThreadEnforcer NONE = new ThreadEnforcer() {
38 | @Override public void enforce(Bus bus) {
39 | // Allow any thread.
40 | }
41 | };
42 |
43 | /** A {@link ThreadEnforcer} that confines {@link Bus} methods to the main thread. */
44 | ThreadEnforcer MAIN = new ThreadEnforcer() {
45 | @Override public void enforce(Bus bus) {
46 | if (Looper.myLooper() != Looper.getMainLooper()) {
47 | throw new IllegalStateException("Event bus " + bus + " accessed from non-main thread " + Looper.myLooper());
48 | }
49 | }
50 | };
51 |
52 | }
53 |
--------------------------------------------------------------------------------
/res/layout/fragment_create_account.xml:
--------------------------------------------------------------------------------
1 |
2 | This class only verifies the suitability of the method and event type if something fails. Callers are expected
26 | * to verify their uses of this class.
27 | *
28 | * @author Jake Wharton
29 | */
30 | class EventProducer {
31 |
32 | /** Object sporting the producer method. */
33 | private final Object target;
34 | /** Producer method. */
35 | private final Method method;
36 | /** Object hash code. */
37 | private final int hashCode;
38 | /** Should this producer produce events? */
39 | private boolean valid = true;
40 |
41 | EventProducer(Object target, Method method) {
42 | if (target == null) {
43 | throw new NullPointerException("EventProducer target cannot be null.");
44 | }
45 | if (method == null) {
46 | throw new NullPointerException("EventProducer method cannot be null.");
47 | }
48 |
49 | this.target = target;
50 | this.method = method;
51 | method.setAccessible(true);
52 |
53 | // Compute hash code eagerly since we know it will be used frequently and we cannot estimate the runtime of the
54 | // target's hashCode call.
55 | final int prime = 31;
56 | hashCode = (prime + method.hashCode()) * prime + target.hashCode();
57 | }
58 |
59 | public boolean isValid() {
60 | return valid;
61 | }
62 |
63 | /**
64 | * If invalidated, will subsequently refuse to produce events.
65 | *
66 | * Should be called when the wrapped object is unregistered from the Bus.
67 | */
68 | public void invalidate() {
69 | valid = false;
70 | }
71 |
72 | /**
73 | * Invokes the wrapped producer method.
74 | *
75 | * @throws java.lang.IllegalStateException if previously invalidated.
76 | * @throws java.lang.reflect.InvocationTargetException if the wrapped method throws any {@link Throwable} that is not
77 | * an {@link Error} ({@code Error}s are propagated as-is).
78 | */
79 | public Object produceEvent() throws InvocationTargetException {
80 | if (!valid) {
81 | throw new IllegalStateException(toString() + " has been invalidated and can no longer produce events.");
82 | }
83 | try {
84 | return method.invoke(target);
85 | } catch (IllegalAccessException e) {
86 | throw new AssertionError(e);
87 | } catch (InvocationTargetException e) {
88 | if (e.getCause() instanceof Error) {
89 | throw (Error) e.getCause();
90 | }
91 | throw e;
92 | }
93 | }
94 |
95 | @Override public String toString() {
96 | return "[EventProducer " + method + "]";
97 | }
98 |
99 | @Override public int hashCode() {
100 | return hashCode;
101 | }
102 |
103 | @Override public boolean equals(Object obj) {
104 | if (this == obj) {
105 | return true;
106 | }
107 |
108 | if (obj == null) {
109 | return false;
110 | }
111 |
112 | if (getClass() != obj.getClass()) {
113 | return false;
114 | }
115 |
116 | final EventProducer other = (EventProducer) obj;
117 |
118 | return method.equals(other.method) && target == other.target;
119 | }
120 |
121 | }
122 |
--------------------------------------------------------------------------------
/src/com/squareup/otto/EventHandler.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2012 Square, Inc.
3 | * Copyright (C) 2007 The Guava Authors
4 | *
5 | * Licensed under the Apache License, Version 2.0 (the "License");
6 | * you may not use this file except in compliance with the License.
7 | * You may obtain a copy of the License at
8 | *
9 | * http://www.apache.org/licenses/LICENSE-2.0
10 | *
11 | * Unless required by applicable law or agreed to in writing, software
12 | * distributed under the License is distributed on an "AS IS" BASIS,
13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 | * See the License for the specific language governing permissions and
15 | * limitations under the License.
16 | */
17 |
18 | package com.squareup.otto;
19 |
20 | import java.lang.reflect.InvocationTargetException;
21 | import java.lang.reflect.Method;
22 |
23 | /**
24 | * Wraps a single-argument 'handler' method on a specific object.
25 | *
26 | * This class only verifies the suitability of the method and event type if something fails. Callers are expected t
27 | * verify their uses of this class.
28 | *
29 | * Two EventHandlers are equivalent when they refer to the same method on the same object (not class). This
30 | * property is used to ensure that no handler method is registered more than once.
31 | *
32 | * @author Cliff Biffle
33 | */
34 | class EventHandler {
35 |
36 | /** Object sporting the handler method. */
37 | private final Object target;
38 | /** Handler method. */
39 | private final Method method;
40 | /** Object hash code. */
41 | private final int hashCode;
42 | /** Should this handler receive events? */
43 | private boolean valid = true;
44 |
45 | EventHandler(Object target, Method method) {
46 | if (target == null) {
47 | throw new NullPointerException("EventHandler target cannot be null.");
48 | }
49 | if (method == null) {
50 | throw new NullPointerException("EventHandler method cannot be null.");
51 | }
52 |
53 | this.target = target;
54 | this.method = method;
55 | method.setAccessible(true);
56 |
57 | // Compute hash code eagerly since we know it will be used frequently and we cannot estimate the runtime of the
58 | // target's hashCode call.
59 | final int prime = 31;
60 | hashCode = (prime + method.hashCode()) * prime + target.hashCode();
61 | }
62 |
63 | public boolean isValid() {
64 | return valid;
65 | }
66 |
67 | /**
68 | * If invalidated, will subsequently refuse to handle events.
69 | *
70 | * Should be called when the wrapped object is unregistered from the Bus.
71 | */
72 | public void invalidate() {
73 | valid = false;
74 | }
75 |
76 | /**
77 | * Invokes the wrapped handler method to handle {@code event}.
78 | *
79 | * @param event event to handle
80 | * @Throws java.lang.IllegalStateException if previously invalidated.
81 | * @throws java.lang.reflect.InvocationTargetException if the wrapped method throws any {@link Throwable} that is not
82 | * an {@link Error} ({@code Error}s are propagated as-is).
83 | */
84 | public void handleEvent(Object event) throws InvocationTargetException {
85 | if (!valid) {
86 | throw new IllegalStateException(toString() + " has been invalidated and can no longer handle events.");
87 | }
88 | try {
89 | method.invoke(target, new Object[] {event});
90 | } catch (IllegalAccessException e) {
91 | throw new AssertionError(e);
92 | } catch (InvocationTargetException e) {
93 | if (e.getCause() instanceof Error) {
94 | throw (Error) e.getCause();
95 | }
96 | throw e;
97 | }
98 | }
99 |
100 | @Override public String toString() {
101 | return "[EventHandler " + method + "]";
102 | }
103 |
104 | @Override public int hashCode() {
105 | return hashCode;
106 | }
107 |
108 | @Override public boolean equals(Object obj) {
109 | if (this == obj) {
110 | return true;
111 | }
112 |
113 | if (obj == null) {
114 | return false;
115 | }
116 |
117 | if (getClass() != obj.getClass()) {
118 | return false;
119 | }
120 |
121 | final EventHandler other = (EventHandler) obj;
122 |
123 | return method.equals(other.method) && target == other.target;
124 | }
125 |
126 | }
127 |
--------------------------------------------------------------------------------
/src/com/keyconsultant/parse/logintutorial/LoginActivity.java:
--------------------------------------------------------------------------------
1 | package com.keyconsultant.parse.logintutorial;
2 |
3 | import android.content.Intent;
4 | import android.os.Bundle;
5 | import android.support.v4.app.FragmentManager;
6 | import android.support.v4.app.FragmentTransaction;
7 | import android.view.Menu;
8 | import android.view.MenuItem;
9 | import android.widget.Toast;
10 |
11 | import com.keyconsultant.parse.logintutorial.activity.BaseActivity;
12 | import com.keyconsultant.parse.logintutorial.forgotpassword.ForgotPasswordDialogFragment;
13 | import com.keyconsultant.parse.logintutorial.model.user.authenticate.AuthenticateUserErrorEvent;
14 | import com.keyconsultant.parse.logintutorial.model.user.authenticate.AuthenticateUserStartEvent;
15 | import com.keyconsultant.parse.logintutorial.model.user.authenticate.AuthenticateUserSuccessEvent;
16 | import com.keyconsultant.parse.logintutorial.model.user.authenticate.UserForgotPasswordErrorEvent;
17 | import com.keyconsultant.parse.logintutorial.model.user.authenticate.UserForgotPasswordStartEvent;
18 | import com.keyconsultant.parse.logintutorial.model.user.authenticate.UserForgotPasswordSuccessEvent;
19 | import com.parse.Parse;
20 | import com.squareup.otto.Subscribe;
21 |
22 | /**
23 | * Activity which displays a login screen to the user, offering registration as
24 | * well. Based loosley on the default Login template.
25 | *
26 | * @author Trey Robinson
27 | */
28 | public class LoginActivity extends BaseActivity {
29 |
30 | @Override
31 | protected void onCreate(Bundle savedInstanceState) {
32 | super.onCreate(savedInstanceState);
33 | setContentView(R.layout.activity_login);
34 |
35 |
36 | Parse.initialize(this, "Your App Id", "Your Client ID");
37 |
38 | FragmentManager fragmentManager = getSupportFragmentManager();
39 | FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();
40 | fragmentTransaction.replace(R.id.main_view, LoginFragment.newInstance());
41 | fragmentTransaction.commit();
42 |
43 | }
44 |
45 | @Override
46 | public boolean onCreateOptionsMenu(Menu menu) {
47 | super.onCreateOptionsMenu(menu);
48 | getMenuInflater().inflate(R.menu.activity_login, menu);
49 | return true;
50 | }
51 |
52 | @Override
53 | public boolean onOptionsItemSelected(MenuItem item) {
54 | // Handle item selection
55 | switch (item.getItemId()) {
56 | case R.id.menu_forgot_password:
57 | forgotPassword();
58 | return true;
59 | default:
60 | return super.onOptionsItemSelected(item);
61 | }
62 | }
63 |
64 | /**
65 | * Open the forgotPassword dialog
66 | */
67 | private void forgotPassword(){
68 | FragmentManager fm = getSupportFragmentManager();
69 | ForgotPasswordDialogFragment forgotPasswordDialog = new ForgotPasswordDialogFragment();
70 | forgotPasswordDialog.show(fm, null);
71 | }
72 |
73 |
74 | @Subscribe
75 | public void onSignInStart(AuthenticateUserStartEvent event){
76 | showProgress(true, getString(R.string.login_progress_signing_in));
77 | }
78 |
79 | @Subscribe
80 | public void onSignInSuccess(AuthenticateUserSuccessEvent event){
81 | showProgress(false, getString(R.string.login_progress_signing_in));
82 | Intent loginSuccess = new Intent(this, MainActivity.class);
83 | startActivity(loginSuccess);
84 | finish();
85 | }
86 |
87 | @Subscribe
88 | public void onSignInError(AuthenticateUserErrorEvent event){
89 | showProgress(false, getString(R.string.login_progress_signing_in));
90 | }
91 |
92 | @Subscribe
93 | public void onForgotPasswordStart(UserForgotPasswordStartEvent event){
94 | showProgress(true, getString(R.string.login_progress_signing_in));
95 | }
96 |
97 | @Subscribe
98 | public void onForgotPasswordSuccess(UserForgotPasswordSuccessEvent event){
99 | showProgress(false,getString(R.string.login_progress_signing_in));
100 | Toast toast =Toast.makeText(this, "A password reset email has been sent.", Toast.LENGTH_LONG);
101 | toast.show();
102 | }
103 |
104 | @Subscribe
105 | public void onForgotPasswordError(UserForgotPasswordErrorEvent event){
106 | showProgress(false, getString(R.string.login_progress_signing_in));
107 | Toast toast =Toast.makeText(this, "An error has occured. Please try again.", Toast.LENGTH_LONG);
108 | toast.show();
109 | }
110 | }
111 |
--------------------------------------------------------------------------------
/src/com/keyconsultant/parse/logintutorial/model/user/UserManager.java:
--------------------------------------------------------------------------------
1 | package com.keyconsultant.parse.logintutorial.model.user;
2 |
3 | import com.keyconsultant.parse.logintutorial.model.manager.BaseManager;
4 | import com.keyconsultant.parse.logintutorial.model.user.authenticate.AuthenticateUserErrorEvent;
5 | import com.keyconsultant.parse.logintutorial.model.user.authenticate.AuthenticateUserStartEvent;
6 | import com.keyconsultant.parse.logintutorial.model.user.authenticate.AuthenticateUserSuccessEvent;
7 | import com.keyconsultant.parse.logintutorial.model.user.authenticate.UserForgotPasswordErrorEvent;
8 | import com.keyconsultant.parse.logintutorial.model.user.authenticate.UserForgotPasswordStartEvent;
9 | import com.keyconsultant.parse.logintutorial.model.user.authenticate.UserForgotPasswordSuccessEvent;
10 | import com.parse.LogInCallback;
11 | import com.parse.ParseException;
12 | import com.parse.ParseUser;
13 | import com.parse.RequestPasswordResetCallback;
14 | import com.parse.SignUpCallback;
15 | import com.squareup.otto.Produce;
16 |
17 | /**
18 | * Manages user authentication and account updates
19 | *
20 | * @author Trey Robinson
21 | *
22 | */
23 | public class UserManager extends BaseManager {
24 |
25 | private static UserManager mManager;
26 |
27 | public static UserManager getInstance() {
28 | if (mManager == null) {
29 | mManager = new UserManager();
30 | }
31 |
32 | return mManager;
33 | }
34 |
35 | /**
36 | * @return Current user
37 | */
38 | public ParseUser getUser() {
39 | return ParseUser.getCurrentUser();
40 | }
41 |
42 | /**
43 | * Authenticate the user
44 | *
45 | * @param username
46 | * Username for the account
47 | * @param password
48 | * Password for the account
49 | */
50 | public void authenticate(String username, String password) {
51 | postEvent(produceUserSignInStartEvent());
52 | ParseUser.logInInBackground(username, password, new UserLogInCallback());
53 | }
54 |
55 | /**
56 | * Create new user. If the user email already exists an error will be
57 | * dispatched via the service bus
58 | *
59 | * @param email
60 | * The user email for the new account
61 | * @param password
62 | * Password for the new account
63 | */
64 | public void signUp(String username, String email, String password) {
65 | User newUser = new User(username, email, password);
66 | postEvent(produceUserSignInStartEvent());
67 | newUser.signUpInBackground(new UserSignUpCallback(newUser));
68 | }
69 |
70 | /**
71 | * Dispatches a forgot password request. The request will send an email to the address if an account for that address exists.
72 | * @param email
73 | * Email for the account that has forgotten their password
74 | */
75 | public void forgotPassword(String email) {
76 | postEvent(new UserForgotPasswordStartEvent());
77 | ParseUser.requestPasswordResetInBackground(email, new UserForgotPasswordCallback());
78 | }
79 |
80 | /**
81 | * Creates an event notifying that authentication has begun
82 | *
83 | * @return
84 | */
85 | @Produce
86 | public AuthenticateUserStartEvent produceUserSignInStartEvent() {
87 | return new AuthenticateUserStartEvent();
88 | }
89 |
90 | /**
91 | * Creates an event containing the signed in user
92 | *
93 | * @param user
94 | * User currently signed in
95 | * @return
96 | */
97 | @Produce
98 | public AuthenticateUserSuccessEvent produceUserSignInSuccessEvent(
99 | ParseUser user) {
100 | return new AuthenticateUserSuccessEvent(user);
101 | }
102 |
103 | /**
104 | * Creates an even for sign in errors
105 | *
106 | * @return
107 | */
108 | @Produce
109 | public AuthenticateUserErrorEvent produceUserSignInErrorEvent(
110 | ParseException exception) {
111 | return new AuthenticateUserErrorEvent(exception);
112 | }
113 |
114 | /**
115 | * Creates an event notifying that forgot password has begun
116 | *
117 | * @return
118 | */
119 | @Produce
120 | public UserForgotPasswordStartEvent produceUserForgotPasswordStartEvent() {
121 | return new UserForgotPasswordStartEvent();
122 | }
123 |
124 | /**
125 | * Creates an event for successful Forgot Password request
126 | *
127 | * @param user
128 | * User currently signed in
129 | * @return
130 | */
131 | @Produce
132 | public UserForgotPasswordSuccessEvent produceUserForgotPasswordSuccessEvent() {
133 | return new UserForgotPasswordSuccessEvent();
134 | }
135 |
136 | /**
137 | * Creates an event for failed Forgot Password attempt
138 | *
139 | * @return
140 | */
141 | @Produce
142 | public UserForgotPasswordErrorEvent produceUserForgotPasswordErrorEvent(ParseException exception) {
143 | return new UserForgotPasswordErrorEvent(exception);
144 | }
145 |
146 | private class UserSignUpCallback extends SignUpCallback {
147 |
148 | User user;
149 |
150 | public UserSignUpCallback(User user) {
151 | this.user = user;
152 | }
153 |
154 | @Override
155 | public void done(ParseException e) {
156 | if (e == null) {
157 | postEvent(produceUserSignInSuccessEvent(user));
158 | } else {
159 | postEvent(produceUserSignInErrorEvent(e));
160 | }
161 |
162 | }
163 | }
164 |
165 | private class UserLogInCallback extends LogInCallback {
166 |
167 | public UserLogInCallback() {
168 | super();
169 | }
170 |
171 | @Override
172 | public void done(ParseUser user, ParseException e) {
173 | if (e == null) {
174 | postEvent(produceUserSignInSuccessEvent(user));
175 | } else {
176 | postEvent(produceUserSignInErrorEvent(e));
177 | }
178 | }
179 | }
180 |
181 | private class UserForgotPasswordCallback extends RequestPasswordResetCallback{
182 | public UserForgotPasswordCallback(){
183 | super();
184 | }
185 |
186 | @Override
187 | public void done(ParseException e) {
188 | if (e == null) {
189 | postEvent(produceUserForgotPasswordSuccessEvent());
190 | } else {
191 | postEvent(produceUserForgotPasswordErrorEvent(e));
192 | }
193 | }
194 | }
195 | }
196 |
--------------------------------------------------------------------------------
/src/com/keyconsultant/parse/logintutorial/LoginFragment.java:
--------------------------------------------------------------------------------
1 | package com.keyconsultant.parse.logintutorial;
2 |
3 | import java.util.Locale;
4 |
5 | import android.os.Bundle;
6 | import android.support.v4.app.FragmentManager;
7 | import android.support.v4.app.FragmentTransaction;
8 | import android.text.TextUtils;
9 | import android.view.KeyEvent;
10 | import android.view.LayoutInflater;
11 | import android.view.View;
12 | import android.view.ViewGroup;
13 | import android.view.inputmethod.EditorInfo;
14 | import android.widget.EditText;
15 | import android.widget.TextView;
16 |
17 | import com.keyconsultant.parse.logintutorial.error.UnknownErrorDialogFactory;
18 | import com.keyconsultant.parse.logintutorial.fragment.BaseFragment;
19 | import com.keyconsultant.parse.logintutorial.model.user.UserManager;
20 | import com.keyconsultant.parse.logintutorial.model.user.authenticate.AuthenticateUserErrorEvent;
21 | import com.parse.ParseException;
22 | import com.squareup.otto.Subscribe;
23 |
24 | /**
25 | * Fragment for logging in. Includes button for loading the Create account view.
26 | *
27 | * @author Trey Robinson
28 | *
29 | */
30 | public class LoginFragment extends BaseFragment {
31 |
32 | public static final String EXTRA_USERNAME = "com.keyconsultant.parse.logintutorial.activity.extra.USERNAME";
33 | public static final String EXTRA_PASSWORD = "com.keyconsultant.parse.logintutorial.activity.extra.PASSWORD";
34 |
35 | // UI references.
36 | private EditText mUserNameEditText;
37 | private EditText mPasswordEditText;
38 |
39 | /**
40 | * Factory method for creating new fragments
41 | * @return
42 | */
43 | public static LoginFragment newInstance(){
44 | return new LoginFragment();
45 | }
46 |
47 | @Override
48 | public View onCreateView(LayoutInflater inflater, ViewGroup container,
49 | Bundle savedInstanceState) {
50 |
51 |
52 | View view = inflater.inflate(R.layout.fragment_login, container, false);
53 | mUserNameEditText = (EditText) view.findViewById(R.id.username);
54 |
55 | mPasswordEditText = (EditText) view.findViewById(R.id.password);
56 | mPasswordEditText.setOnEditorActionListener(new TextView.OnEditorActionListener() {
57 | @Override
58 | public boolean onEditorAction(TextView textView, int id, KeyEvent keyEvent) {
59 | if (id == R.id.login || id == EditorInfo.IME_NULL) {
60 | attemptLogin();
61 | return true;
62 | }
63 | return false;
64 | }
65 | });
66 |
67 | view.findViewById(R.id.sign_in_button).setOnClickListener(new View.OnClickListener() {
68 | @Override
69 | public void onClick(View view) {
70 | attemptLogin();
71 | }
72 | });
73 |
74 | view.findViewById(R.id.register_button).setOnClickListener(new View.OnClickListener() {
75 | @Override
76 | public void onClick(View view) {
77 | createAccount();
78 | }
79 | });
80 | return view;
81 | }
82 |
83 | @Override
84 | public void onActivityCreated(Bundle savedInstanceState) {
85 | super.onActivityCreated(savedInstanceState);
86 | if(savedInstanceState != null){
87 | mUserNameEditText.setText(savedInstanceState.getString(EXTRA_USERNAME));
88 | mPasswordEditText.setText(savedInstanceState.getString(EXTRA_PASSWORD));
89 | }
90 | }
91 |
92 | @Override
93 | public void onSaveInstanceState(Bundle outState) {
94 | super.onSaveInstanceState(outState);
95 | outState.putString(EXTRA_USERNAME, mUserNameEditText.getText().toString());
96 | outState.putString(EXTRA_PASSWORD, mPasswordEditText.getText().toString());
97 | }
98 |
99 | /**
100 | * Attempts to sign in or register the account specified by the login form.
101 | * If there are form errors (invalid email, missing fields, etc.), the
102 | * errors are presented and no actual login attempt is made.
103 | */
104 | public void attemptLogin() {
105 |
106 | clearErrors();
107 |
108 | // Store values at the time of the login attempt.
109 | String username = mUserNameEditText.getText().toString();
110 | String password = mPasswordEditText.getText().toString();
111 |
112 | boolean cancel = false;
113 | View focusView = null;
114 |
115 | // Check for a valid password.
116 | if (TextUtils.isEmpty(password)) {
117 | mPasswordEditText.setError(getString(R.string.error_field_required));
118 | focusView = mPasswordEditText;
119 | cancel = true;
120 | } else if (password.length() < 4) {
121 | mPasswordEditText.setError(getString(R.string.error_invalid_password));
122 | focusView =mPasswordEditText;
123 | cancel = true;
124 | }
125 |
126 | // Check for a valid email address.
127 | if (TextUtils.isEmpty(username)) {
128 | mUserNameEditText.setError(getString(R.string.error_field_required));
129 | focusView = mUserNameEditText;
130 | cancel = true;
131 | }
132 |
133 | if (cancel) {
134 | // There was an error; don't attempt login and focus the first
135 | // form field with an error.
136 | focusView.requestFocus();
137 | } else {
138 | // perform the user login attempt.
139 | UserManager.getInstance().authenticate(username.toLowerCase(Locale.getDefault()), password);
140 | }
141 | }
142 |
143 | /**
144 | * Load the create account view.
145 | */
146 | private void createAccount(){
147 | FragmentManager fragmentManager = getActivity().getSupportFragmentManager();
148 | FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();
149 | fragmentTransaction.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_OPEN);
150 | fragmentTransaction.replace(((ViewGroup)getView().getParent()).getId(), CreateAccountFragment.newInstance());
151 | fragmentTransaction.addToBackStack(null);
152 | fragmentTransaction.commit();
153 | }
154 |
155 | /**
156 | * Remove all edit text errors
157 | */
158 | private void clearErrors(){
159 | mUserNameEditText.setError(null);
160 | mPasswordEditText.setError(null);
161 | }
162 |
163 | @Subscribe
164 | public void onSignInError(AuthenticateUserErrorEvent event){
165 | clearErrors();
166 | switch (event.getErrorCode()) {
167 | case ParseException.OBJECT_NOT_FOUND:
168 | mPasswordEditText.setError(getString(R.string.error_incorrect_password));
169 | mPasswordEditText.requestFocus();
170 | break;
171 | default:
172 | UnknownErrorDialogFactory.createUnknownErrorDialog(this.getActivity()).show();
173 | break;
174 | }
175 | }
176 | }
177 |
--------------------------------------------------------------------------------
/src/com/squareup/otto/AnnotatedHandlerFinder.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2012 Square, Inc.
3 | * Copyright (C) 2007 The Guava Authors
4 | *
5 | * Licensed under the Apache License, Version 2.0 (the "License");
6 | * you may not use this file except in compliance with the License.
7 | * You may obtain a copy of the License at
8 | *
9 | * http://www.apache.org/licenses/LICENSE-2.0
10 | *
11 | * Unless required by applicable law or agreed to in writing, software
12 | * distributed under the License is distributed on an "AS IS" BASIS,
13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 | * See the License for the specific language governing permissions and
15 | * limitations under the License.
16 | */
17 |
18 | package com.squareup.otto;
19 |
20 | import java.lang.reflect.Method;
21 | import java.lang.reflect.Modifier;
22 | import java.util.HashMap;
23 | import java.util.HashSet;
24 | import java.util.Map;
25 | import java.util.Set;
26 |
27 | /**
28 | * Helper methods for finding methods annotated with {@link Produce} and {@link Subscribe}.
29 | *
30 | * @author Cliff Biffle
31 | * @author Louis Wasserman
32 | * @author Jake Wharton
33 | */
34 | final class AnnotatedHandlerFinder {
35 |
36 | /** Cache event bus producer methods for each class. */
37 | private static final Map The Bus allows publish-subscribe-style communication between components without requiring the components to
38 | * explicitly register with one another (and thus be aware of each other). It is designed exclusively to replace
39 | * traditional Android in-process event distribution using explicit registration or listeners. It is not a
40 | * general-purpose publish-subscribe system, nor is it intended for interprocess communication.
41 | *
42 | * Events are routed based on their type — an event will be delivered to any handler for any type to which the
57 | * event is assignable. This includes implemented interfaces, all superclasses, and all interfaces implemented
58 | * by superclasses.
59 | *
60 | * When {@code post} is called, all registered handlers for an event are run in sequence, so handlers should be
61 | * reasonably quick. If an event may trigger an extended process (such as a database load), spawn a thread or queue it
62 | * for later.
63 | *
64 | * Handlers should not, in general, throw. If they do, the Bus will wrap the exception and
68 | * re-throw it.
69 | *
70 | * The Bus by default enforces that all interactions occur on the main thread. You can provide an alternate
71 | * enforcement by passing a {@link ThreadEnforcer} to the constructor.
72 | *
73 | * This class is safe for concurrent use.
84 | *
85 | * @author Cliff Biffle
86 | * @author Jake Wharton
87 | */
88 | public class Bus {
89 | public static final String DEFAULT_IDENTIFIER = "default";
90 |
91 | /** All registered event handlers, indexed by event type. */
92 | private final ConcurrentMap
176 | * If any subscribers are registering for types which already have a producer they will be called immediately
177 | * with the result of calling that producer.
178 | *
179 | * If any producers are registering for types which already have subscribers, each subscriber will be called with
180 | * the value from the result of calling the producer.
181 | *
182 | * @param object object whose handler methods should be registered.
183 | */
184 | public void register(Object object) {
185 | enforcer.enforce(this);
186 |
187 | Map If no handlers have been subscribed for {@code event}'s class, and {@code event} is not already a
297 | * {@link DeadEvent}, it will be wrapped in a DeadEvent and reposted.
298 | *
299 | * @param event event to post.
300 | */
301 | public void post(Object event) {
302 | enforcer.enforce(this);
303 |
304 | SetReceiving Events
43 | * To receive events, an object should:
44 | *
45 | *
51 | *
52 | * Posting Events
53 | * To post an event, simply provide the event object to the {@link #post(Object)} method. The Bus instance will
54 | * determine the type of event and route it to all registered listeners.
55 | *
56 | * Handler Methods
65 | * Event handler methods must accept only one argument: the event.
66 | *
67 | * Producer Methods
74 | * Producer methods should accept no arguments and return their event type. When a subscriber is registered for a type
75 | * that a producer is also already registered for, the subscriber will be called with the return value from the
76 | * producer.
77 | *
78 | * Dead Events
79 | * If an event is posted, but no registered handlers can accept it, it is considered "dead." To give the system a
80 | * second chance to handle dead events, they are wrapped in an instance of {@link com.squareup.otto.DeadEvent} and
81 | * reposted.
82 | *
83 | *