안드로이드로 구글 클래스룸 연동하기.(Google Classroom api in Android).

// TestActivity.java

public class TestActivity extends AppCompatActivity {
  private static final int REQUEST_CODE_SIGN_IN = 9001;
  private GoogleSignInClient mGoogleSignInClient;
  private ClassroomServiceHelper mClassroomServiceHelper;

  @Override
  protected void onResume() {
      super.onResume();

      int type = 0;
      GoogleSignInAccount account = GoogleSignIn.getLastSignedInAccount(mContext);
      Set<String> scopes = new HashSet<>();
        scopes.add(ClassroomScopes.CLASSROOM_COURSES);
        scopes.add(ClassroomScopes.CLASSROOM_COURSEWORK_STUDENTS);
      if (account != null && account.getGrantedScopes().containsAll(scopes)) {
          type = 1;
      }

      updateUI(type);
  }

  private void updateUI(int type) {
      if(type == 0) {
          // 구글 클래스룸 연동 버튼 보이기.
      }
      else {
          // Classroom 인스턴스 생성 및 코스 가져오기 버튼.
          // 로그아웃 버튼 보이기.
      }
  }

  // 구글 클래스룸 연동 버튼 눌렸을 때.
  private void loginGoogleClassroomBtnPressed(View v) {
      GoogleSignInOptions signInOptions =
              new GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_SIGN_IN)
                      .requestEmail()
                      .requestScopes(new Scope(ClassroomScopes.CLASSROOM_COURSES))
                      .requestScopes(new Scope(ClassroomScopes.CLASSROOM_COURSEWORK_STUDENTS))
                      .build();
      mGoogleSignInClient = GoogleSignIn.getClient(this, signInOptions);

      // The result of the sign-in Intent is handled in onActivityResult.
      startActivityForResult(mGoogleSignInClient.getSignInIntent(), REQUEST_CODE_SIGN_IN);
  }

  private void logout(final int type) {
      mGoogleSignInClient.signOut().addOnCompleteListener(this, new OnCompleteListener<Void>() {
          @Override
          public void onComplete(@NonNull Task<Void> task) {
              updateUI(0);
          }
      });
  }

  @Override
   protected void onActivityResult(int requestCode, int resultCode, Intent data) {
       super.onActivityResult(requestCode, resultCode, data);
       if(requestCode == REQUEST_CODE_SIGN_IN) {
           if (resultCode == Activity.RESULT_OK && data != null) {
               handleSignInResult(data);
           }
       }
   }

   private void handleSignInResult(Intent result) {
        GoogleSignIn.getSignedInAccountFromIntent(result)
                .addOnSuccessListener(new OnSuccessListener<GoogleSignInAccount>() {
                    @Override
                    public void onSuccess(GoogleSignInAccount googleSignInAccount) {
                        Log.d(TAG, "Signed in as " + googleSignInAccount.getEmail());

                        updateUI(1);

                        // Use the authenticated account to sign in to the Drive service.
                    }
                })
                .addOnFailureListener(new OnFailureListener() {
                    @Override
                    public void onFailure(@NonNull Exception e) {
                        Log.e(TAG, "Unable to open file from picker.", e);
                    }
                });
    }

    public void getCourseAndCourseWork(View v) {
        makeClassroomHelper();
        mClassroomServiceHelper.listCourses()
                      .addOnSuccessListener(new OnSuccessListener<List<Course>>() {
                          @Override
                          public void onSuccess(List<Course> courses) {
                              if(courses.size() > 0) {
                                  Course course = courses.get(0);

                                  // Get courseworks in selected course.
                                  mClassroomServiceHelper.listCourseWorks(course.getId())
                                          .addOnSuccessListener(new OnSuccessListener<List<CourseWork>>() {
                                              @Override
                                              public void onSuccess(List<CourseWork> courseWorks) {
                                                  Log.d(TAG, "CourseWork size : " + courseWorks.size());
                                              }
                                          })
                                          .addOnFailureListener(new OnFailureListener() {
                                              @Override
                                              public void onFailure(@NonNull Exception e) {

                                              }
                                          });
                              }
                          }
                      })
                      .addOnFailureListener(new OnFailureListener() {
                          @Override
                          public void onFailure(@NonNull Exception e) {

                          }
                      });
    }

    public void makeClassroomHelper() {
        Set<String> scopes = new HashSet<>();
        scopes.add(ClassroomScopes.CLASSROOM_COURSES);
        scopes.add(ClassroomScopes.CLASSROOM_COURSEWORK_STUDENTS);
        GoogleSignInAccount googleSignInAccount = GoogleSignIn.getLastSignedInAccount(this);
        GoogleAccountCredential credential =
                GoogleAccountCredential.usingOAuth2(
                        this,  scopes);
        credential.setSelectedAccount(googleSignInAccount.getAccount());
        Classroom service = new Classroom.Builder(AndroidHttp.newCompatibleTransport(), new GsonFactory(), credential)
                .setApplicationName("GRExample")
                .build();

        mClassroomServiceHelper = new ClassroomServiceHelper(service);
    }
}

// ClassroomServiceHelper.java

public class ClassroomServiceHelper {

    // If you don't want to multiThread, use 'newSingleThreadExecutor' method.
    private final Executor mExecutor = Executors.newFixedThreadPool(5);
    private final Classroom mClassroomService;

    public ClassroomServiceHelper(Classroom ClassroomService) {
        mClassroomService = ClassroomService;
    }

    public Task<List<Course>> listCourses() {
        return Tasks.call(mExecutor, new Callable<List<Course>>() {
            @Override
            public List<Course> call() throws Exception {
                ListCoursesResponse response = mClassroomService.courses().list()
                        .setPageSize(10)
                        .execute();

                List<Course> courses = response.getCourses();

                return courses;
            }
        });
    }

    public Task<List<CourseWork>> listCourseWorks(final String courseId) {
        return Tasks.call(mExecutor, new Callable<List<CourseWork>>() {
            @Override
            public List<CourseWork> call() throws Exception {
                ListCourseWorkResponse response = mClassroomService.courses().
                        courseWork().list(courseId).execute();


                List<CourseWork> courseWorks = response.getCourseWork();

                return courseWorks;
            }
        });
    }

    // You can make other method for getting assignments so on.

    public Task<List<Course>> listCoursesForCancalable(CancellationToken token) {
        token.onCanceledRequested(new OnTokenCanceledListener() {
            @Override
            public void onCanceled() {
                // Do something after task is canceled.
            }
        });

        final TaskCompletionSource<List<Course>> tcs = new TaskCompletionSource<>(token);

        mExecutor.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    ListCoursesResponse response = mClassroomService.courses().list()
                            .setPageSize(10)
                            .execute();

                    List<Course> courses = response.getCourses();

                    // If the token is canceled, task's state is 'complete'.
                    if(!tcs.getTask().isComplete()) {
                        tcs.setResult(courses);
                    }
                } catch (IOException e) {
                    tcs.setResult(null);
                    e.printStackTrace();
                }
            }
        });

        return tcs.getTask();
    }

    public Task<List<CourseWork>> listCourseWorksForCancelable(final String courseId, CancellationToken token) {
        token.onCanceledRequested(new OnTokenCanceledListener() {
            @Override
            public void onCanceled() {
                // Do something after task is canceled.
            }
        });

        final TaskCompletionSource<List<CourseWork>> tcs = new TaskCompletionSource<>(token);

        mExecutor.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    ListCourseWorkResponse response = mClassroomService.courses().
                            courseWork().list(courseId).execute();


                    List<CourseWork> courseWorks = response.getCourseWork();
                    if(!tcs.getTask().isComplete()) {
                        tcs.setResult(courseWorks);
                    }
                } catch (IOException e) {
                    tcs.setResult(null);
                    e.printStackTrace();
                }
            }
        });

        return tcs.getTask();
    }
}