Android에서 Google Calendar API 사용하는 방법

Android에서 Google Calendar API 사용하는 방법Android/달력2021. 5. 14. 20:45@webnautes

Table of Contents

Google Calendar에 캘린더를 생성하고 이벤트를 추가 및 이벤트 리스트를 가져오는 예제코드 입니다.

1. Google Calendar API 사용 설정

2. AndroidManifest.xml

3. build.gradle

4. activity_main.xml

5. MainActivity.java

참고

2018. 7. 30 - 최초 작성

2018. 10. 10 - 인증 관련 버그 수정

Attempt to invoke virtual method 'java.util.List com.google.api.services.calendar.model.CalendarList.getItmes()' on a null object reference

try {
calendarList = mService.calendarList().list().setPageToken(pageToken).execute();
} catch (UserRecoverableAuthIOException e) { // 추가
startActivityForResult(e.getIntent(), REQUEST_AUTHORIZATION);
}catch (IOException e) {
e.printStackTrace();
}

2018. 8. 8 - Google Developers Console 사이트에서 OAuth 2.0 관련 변경사항 반영

androidx 사용

2021. 5. 14 - 웹에서 Google Calendar API 사용하기 위해 필요한 작업이 변경된 점을 반영

우선 실행 결과입니다.

캘린더와 연동 테스트를 진행합니다.

ADD CALENDAR, ADD EVENT, GET EVENT 순으로 버튼을 선택하여 진행했습니다.

ADD CALENDAR를 선택해봅니다.

주소록 사용에 대한 런타임 퍼미션을 물어봅니다. 허용을 선택합니다.

(다른 버튼을 먼저 클릭했다면 똑같이 런타임 퍼미션을 물어봅니다. )

캘린더를 연결할 구글 계정을 선택합니다.

순간적으로 앱에서 에러난 게 보이면서 아래 화면으로 넘어옵니다.

(앱에서 에러 로그 출력을 안하도록 하면 해결될듯합니다. )

허용을 선택합니다.

최근에 테스트를 할건지 물어보는 항목이 추가되었습니다. 앱을 게시하면 보이지 않는 화면인듯합니다.

구글 캘린더에 캘린더를 추가했습니다.

웹용 구글 캘린더에서 확인해보면 CalendarTitle이 추가되어 있습니다.

이제 ADD Event를 선택하여 이벤트를 캘린더에 추가합니다.

GET EVENT를 클릭하면 캘린더에서 가져온 이벤트를 보여줍니다.

(아래는 예전 스크린샷을 그대로 사용했습니다.)

구글 캘린더 API를 사용하기 위한 준비부터 시작합니다.

1. Google Calendar API 사용 설정

1-1. Google Cloud Platform 사이트 (https://console.developers.google.com/apis/dashboard )에 접속하여 프로젝트 만들기를 클릭합니다.

1-2. 프로젝트 이름을 입력하고 만들기를 클릭합니다.

1-3. 왼쪽에 마우스 커서를 가져가면 보이는 메뉴에서 라이브러리를 클릭합니다.

1-4. 검색창에 calendar를 입력하면 보이는 Google Calendar API를 클릭합니다.

1-5. 사용을 클릭합니다.

1-6. Google Calendar API가 활성화 되었습니다. 이제 인증 정보를 추가해야 합니다.

사용자 인증 정보 만들기를 클릭합니다.

1-7. 어떤 API를 사용 중이신가요?에 Google Calendar API, 액세스할 데이터로 사용자 데이터를 선택하고 다음을 클릭합니다.

1-8. 앱 이름을 입력하고 사용자 지원 이메일과 이메일 주소를 입력 한 후, 저장후 계속을 클릭합니다.

1-9. 범위 추가 또는 삭제를 클릭합니다.

1-10. 필터에 “Google Calendar API”를 입력한 후, 검색된 항목에서 필요한 것만 체크합니다.

선택 완료후, 아래쪽에 보이는 업데이트를 클릭합니다.

다음처럼 선택한 항목들이 민감한지 여부를 보여줍니다.

휴지통 아이콘을 클릭하여 필요없는 항목을 제거할 수도 있습니다.

(이 정보만 봐서는 앱에서 어떤 항목이 필요한건지 알기 힘드네요.)

저장 후 계속을 클릭합니다.

1-11. 진행하기 위해서는 SHA1과 패키지 이름이 필요합니다.

먼저 명령 프롬프트에서 다음 명령을 실행하여 SHA1을 출력해둡니다.(빨간색 사각형 부분)

"C:\Program Files\Android\Android Studio\jre\bin\keytool" -list -v -keystore "%USERPROFILE%\.android\debug.keystore" -alias androiddebugkey -storepass android -keypass android

안드로이드 프로젝트(Empty Activity 선택)를 생성하여 패키지 이름을 확인해둡니다.

1-12. 앞에서 확인해둔 SHA1과 패키지 이름을 입력해주고 만들기를 클릭합니다.

1-15. 완료를 클릭합니다.

1-16. 테스트할 사용자를 추가해줘야 합니다. OAuth 동의 화면을 선택합니다.

1-17. ADD USERS를 클릭 후, 테스트할 사용자의 구글 계정을 입력해줘야 합니다.

이제 구글 캘린더 API를 사용할 준비가 완료되었습니다.

OAuth 2.0을 사용하기 때문에 인증을 위해 안드로이드 앱에 추가할 것은 없습니다.

이제 앞에서 생성했던 프로젝트의 코드를 변경합니다.

2. AndroidManifest.xml

매니페스트 파일에 다음 권한들을 추가해줍니다.

<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.GET_ACCOUNTS" />

3. build.gradle

Google API Client Library를 안드로이드 프로젝트에 사용할 수 있도록 패키지를 추가하고 Sync Now를 클릭합니다.

implementation 'androidx.media:media:1.3.1'
implementation 'androidx.legacy:legacy-support-v4:1.0.0'
implementation 'com.google.android.gms:play-services-auth:19.0.0'
implementation 'pub.devrel:easypermissions:0.3.0'
implementation('com.google.api-client:google-api-client-android:1.22.0') {
exclude group: 'org.apache.httpcomponents'
}
implementation('com.google.apis:google-api-services-calendar:v3-rev235-1.22.0') {
exclude group: 'org.apache.httpcomponents'
}

4. activity_main.xml

기존 내용을 교체합니다.

오른쪽 상단에 있는 Code를 클릭한 후 진행합니다.

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:id="@+id/activity_main"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:paddingBottom="16dp"
android:paddingLeft="16dp"
android:paddingRight="16dp"
android:paddingTop="16dp"
android:orientation="vertical"
tools:context=".MainActivity">

<TextView
android:id="@+id/textview_main_status"
android:layout_width="match_parent"
android:layout_height="0dp"
android:layout_weight="40"
android:layout_centerHorizontal="true"
android:layout_marginBottom="10dp"
android:layout_marginEnd="10dp"
android:layout_marginLeft="10dp"
android:layout_marginRight="10dp"
android:layout_marginStart="10dp"
android:layout_marginTop="10dp"
android:text=""/>

<TextView
android:id="@+id/textview_main_result"
android:layout_width="match_parent"
android:layout_height="0dp"
android:layout_weight="80"
android:layout_centerHorizontal="true"
android:layout_marginBottom="10dp"
android:layout_marginEnd="10dp"
android:layout_marginLeft="10dp"
android:layout_marginRight="10dp"
android:layout_marginStart="10dp"
android:layout_marginTop="10dp"
android:text=""/>

<Button
android:id="@+id/button_main_add_calendar"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_centerHorizontal="true"
android:layout_centerVertical="true"
android:text="Add Calendar" />

<Button
android:id="@+id/button_main_add_event"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_centerHorizontal="true"
android:layout_centerVertical="true"
android:text="Add Event" />

<Button
android:id="@+id/button_main_get_event"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_centerHorizontal="true"
android:layout_centerVertical="true"
android:text="Get Event" />

</LinearLayout>

5. MainActivity.java

패키지 선언을 제외하고 모두 지운 후, 붙여넣기합니다.

import com.google.android.gms.common.ConnectionResult;
import com.google.android.gms.common.GoogleApiAvailability;
import com.google.api.client.extensions.android.http.AndroidHttp;
import com.google.api.client.googleapis.extensions.android.gms.auth.GoogleAccountCredential;
import com.google.api.client.googleapis.extensions.android.gms.auth.GooglePlayServicesAvailabilityIOException;
import com.google.api.client.googleapis.extensions.android.gms.auth.UserRecoverableAuthIOException;

import com.google.api.client.http.HttpTransport;
import com.google.api.client.json.JsonFactory;
import com.google.api.client.json.jackson2.JacksonFactory;
import com.google.api.client.util.DateTime;
import com.google.api.client.util.ExponentialBackOff;

import com.google.api.services.calendar.CalendarScopes;

import com.google.api.services.calendar.model.*;

import android.Manifest;
import android.accounts.AccountManager;
import android.app.Activity;
import android.app.Dialog;
import android.app.ProgressDialog;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.os.AsyncTask;
import android.os.Bundle;
import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;

import android.text.TextUtils;
import android.text.method.ScrollingMovementMethod;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;

import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Locale;

import pub.devrel.easypermissions.AfterPermissionGranted;
import pub.devrel.easypermissions.EasyPermissions;

public class MainActivity extends AppCompatActivity implements EasyPermissions.PermissionCallbacks {

/**
* Google Calendar API에 접근하기 위해 사용되는 구글 캘린더 API 서비스 객체
*/

private com.google.api.services.calendar.Calendar mService = null;

/**
* Google Calendar API 호출 관련 메커니즘 및 AsyncTask을 재사용하기 위해 사용
*/
private int mID = 0;

GoogleAccountCredential mCredential;
private TextView mStatusText;
private TextView mResultText;
private Button mGetEventButton;
private Button mAddEventButton;
private Button mAddCalendarButton;
ProgressDialog mProgress;

static final int REQUEST_ACCOUNT_PICKER = 1000;
static final int REQUEST_AUTHORIZATION = 1001;
static final int REQUEST_GOOGLE_PLAY_SERVICES = 1002;
static final int REQUEST_PERMISSION_GET_ACCOUNTS = 1003;

private static final String PREF_ACCOUNT_NAME = "accountName";
private static final String[] SCOPES = {CalendarScopes.CALENDAR};

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);

setContentView(R.layout.activity_main);

mAddCalendarButton = (Button) findViewById(R.id.button_main_add_calendar);
mAddEventButton = (Button) findViewById(R.id.button_main_add_event);
mGetEventButton = (Button) findViewById(R.id.button_main_get_event);

mStatusText = (TextView) findViewById(R.id.textview_main_status);
mResultText = (TextView) findViewById(R.id.textview_main_result);

/**
* 버튼 클릭으로 동작 테스트
*/
mAddCalendarButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
mAddCalendarButton.setEnabled(false);
mStatusText.setText("");
mID = 1; //캘린더 생성
getResultsFromApi();
mAddCalendarButton.setEnabled(true);
}
});

mAddEventButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
mAddEventButton.setEnabled(false);
mStatusText.setText("");
mID = 2; //이벤트 생성
getResultsFromApi();
mAddEventButton.setEnabled(true);
}
});

mGetEventButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
mGetEventButton.setEnabled(false);
mStatusText.setText("");
mID = 3; //이벤트 가져오기
getResultsFromApi();
mGetEventButton.setEnabled(true);
}
});

// Google Calendar API의 호출 결과를 표시하는 TextView를 준비
mResultText.setVerticalScrollBarEnabled(true);
mResultText.setMovementMethod(new ScrollingMovementMethod());

mStatusText.setVerticalScrollBarEnabled(true);
mStatusText.setMovementMethod(new ScrollingMovementMethod());
mStatusText.setText("버튼을 눌러 테스트를 진행하세요.");

// Google Calendar API 호출중에 표시되는 ProgressDialog
mProgress = new ProgressDialog(this);
mProgress.setMessage("Google Calendar API 호출 중입니다.");

// Google Calendar API 사용하기 위해 필요한 인증 초기화( 자격 증명 credentials, 서비스 객체 )
// OAuth 2.0를 사용하여 구글 계정 선택 및 인증하기 위한 준비
mCredential = GoogleAccountCredential.usingOAuth2(
getApplicationContext(),
Arrays.asList(SCOPES)
).setBackOff(new ExponentialBackOff()); // I/O 예외 상황을 대비해서 백오프 정책 사용

}

/**
* 다음 사전 조건을 모두 만족해야 Google Calendar API를 사용할 수 있다.
*
* 사전 조건
* - Google Play Services 설치
* - 유효한 구글 계정 선택
* - 안드로이드 디바이스에서 인터넷 사용 가능
*
* 하나라도 만족하지 않으면 해당 사항을 사용자에게 알림.
*/
private String getResultsFromApi() {

if (!isGooglePlayServicesAvailable()) { // Google Play Services를 사용할 수 없는 경우

acquireGooglePlayServices();
} else if (mCredential.getSelectedAccountName() == null) { // 유효한 Google 계정이 선택되어 있지 않은 경우

chooseAccount();
} else if (!isDeviceOnline()) { // 인터넷을 사용할 수 없는 경우

mStatusText.setText("No network connection available.");
} else {

// Google Calendar API 호출
new MakeRequestTask(this, mCredential).execute();
}
return null;
}

/**
* 안드로이드 디바이스에 최신 버전의 Google Play Services가 설치되어 있는지 확인
*/
private boolean isGooglePlayServicesAvailable() {

GoogleApiAvailability apiAvailability = GoogleApiAvailability.getInstance();

final int connectionStatusCode = apiAvailability.isGooglePlayServicesAvailable(this);
return connectionStatusCode == ConnectionResult.SUCCESS;
}

/*
* Google Play Services 업데이트로 해결가능하다면 사용자가 최신 버전으로 업데이트하도록 유도하기위해
* 대화상자를 보여줌.
*/
private void acquireGooglePlayServices() {

GoogleApiAvailability apiAvailability = GoogleApiAvailability.getInstance();
final int connectionStatusCode = apiAvailability.isGooglePlayServicesAvailable(this);

if (apiAvailability.isUserResolvableError(connectionStatusCode)) {

showGooglePlayServicesAvailabilityErrorDialog(connectionStatusCode);
}
}

/*
* 안드로이드 디바이스에 Google Play Services가 설치 안되어 있거나 오래된 버전인 경우 보여주는 대화상자
*/
void showGooglePlayServicesAvailabilityErrorDialog(
final int connectionStatusCode
) {

GoogleApiAvailability apiAvailability = GoogleApiAvailability.getInstance();

Dialog dialog = apiAvailability.getErrorDialog(
MainActivity.this,
connectionStatusCode,
REQUEST_GOOGLE_PLAY_SERVICES
);
dialog.show();
}

/*
* Google Calendar API의 자격 증명( credentials ) 에 사용할 구글 계정을 설정한다.
*
* 전에 사용자가 구글 계정을 선택한 적이 없다면 다이얼로그에서 사용자를 선택하도록 한다.
* GET_ACCOUNTS 퍼미션이 필요하다.
*/
@AfterPermissionGranted(REQUEST_PERMISSION_GET_ACCOUNTS)
private void chooseAccount() {

// GET_ACCOUNTS 권한을 가지고 있다면
if (EasyPermissions.hasPermissions(this, Manifest.permission.GET_ACCOUNTS)) {

// SharedPreferences에서 저장된 Google 계정 이름을 가져온다.
String accountName = getPreferences(Context.MODE_PRIVATE)
.getString(PREF_ACCOUNT_NAME, null);
if (accountName != null) {

// 선택된 구글 계정 이름으로 설정한다.
mCredential.setSelectedAccountName(accountName);
getResultsFromApi();
} else {

// 사용자가 구글 계정을 선택할 수 있는 다이얼로그를 보여준다.
startActivityForResult(
mCredential.newChooseAccountIntent(),
REQUEST_ACCOUNT_PICKER);
}

// GET_ACCOUNTS 권한을 가지고 있지 않다면
} else {

// 사용자에게 GET_ACCOUNTS 권한을 요구하는 다이얼로그를 보여준다.(주소록 권한 요청함)
EasyPermissions.requestPermissions(
(Activity)this,
"This app needs to access your Google account (via Contacts).",
REQUEST_PERMISSION_GET_ACCOUNTS,
Manifest.permission.GET_ACCOUNTS);
}
}

/*
* 구글 플레이 서비스 업데이트 다이얼로그, 구글 계정 선택 다이얼로그, 인증 다이얼로그에서 되돌아올때 호출된다.
*/

@Override
protected void onActivityResult(
int requestCode, // onActivityResult가 호출되었을 때 요청 코드로 요청을 구분
int resultCode, // 요청에 대한 결과 코드
Intent data
) {
super.onActivityResult(requestCode, resultCode, data);

switch (requestCode) {

case REQUEST_GOOGLE_PLAY_SERVICES:

if (resultCode != RESULT_OK) {

mStatusText.setText( " 앱을 실행시키려면 구글 플레이 서비스가 필요합니다."
+ "구글 플레이 서비스를 설치 후 다시 실행하세요." );
} else {

getResultsFromApi();
}
break;

case REQUEST_ACCOUNT_PICKER:
if (resultCode == RESULT_OK && data != null && data.getExtras() != null) {
String accountName = data.getStringExtra(AccountManager.KEY_ACCOUNT_NAME);
if (accountName != null) {
SharedPreferences settings = getPreferences(Context.MODE_PRIVATE);
SharedPreferences.Editor editor = settings.edit();
editor.putString(PREF_ACCOUNT_NAME, accountName);
editor.apply();
mCredential.setSelectedAccountName(accountName);
getResultsFromApi();
}
}
break;

case REQUEST_AUTHORIZATION:

if (resultCode == RESULT_OK) {
getResultsFromApi();
}
break;
}
}

/*
* Android 6.0 (API 23) 이상에서 런타임 권한 요청시 결과를 리턴받음
*/
@Override
public void onRequestPermissionsResult(
int requestCode, //requestPermissions(android.app.Activity, String, int, String[])에서 전달된 요청 코드
@NonNull String[] permissions, // 요청한 퍼미션
@NonNull int[] grantResults // 퍼미션 처리 결과. PERMISSION_GRANTED 또는 PERMISSION_DENIED
) {
super.onRequestPermissionsResult(requestCode, permissions, grantResults);

EasyPermissions.onRequestPermissionsResult(requestCode, permissions, grantResults, this);
}

/*
* EasyPermissions 라이브러리를 사용하여 요청한 권한을 사용자가 승인한 경우 호출된다.
*/
@Override
public void onPermissionsGranted(int requestCode, List<String> requestPermissionList) {

// 아무일도 하지 않음
}

/*
* EasyPermissions 라이브러리를 사용하여 요청한 권한을 사용자가 거부한 경우 호출된다.
*/
@Override
public void onPermissionsDenied(int requestCode, List<String> requestPermissionList) {

// 아무일도 하지 않음
}

/*
* 안드로이드 디바이스가 인터넷 연결되어 있는지 확인한다. 연결되어 있다면 True 리턴, 아니면 False 리턴
*/
private boolean isDeviceOnline() {

ConnectivityManager connMgr = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo networkInfo = connMgr.getActiveNetworkInfo();

return (networkInfo != null && networkInfo.isConnected());
}

/*
* 캘린더 이름에 대응하는 캘린더 ID를 리턴
*/
private String getCalendarID(String calendarTitle){

String id = null;

// Iterate through entries in calendar list
String pageToken = null;
do {
CalendarList calendarList = null;
try {
calendarList = mService.calendarList().list().setPageToken(pageToken).execute();
} catch (UserRecoverableAuthIOException e) {
startActivityForResult(e.getIntent(), REQUEST_AUTHORIZATION);
}catch (IOException e) {
e.printStackTrace();
}
List<CalendarListEntry> items = calendarList.getItems();

for (CalendarListEntry calendarListEntry : items) {

if ( calendarListEntry.getSummary().toString().equals(calendarTitle)) {

id = calendarListEntry.getId().toString();
}
}
pageToken = calendarList.getNextPageToken();
} while (pageToken != null);

return id;
}

/*
* 비동기적으로 Google Calendar API 호출
*/
private class MakeRequestTask extends AsyncTask<Void, Void, String> {

private Exception mLastError = null;
private MainActivity mActivity;
List<String> eventStrings = new ArrayList<String>();

public MakeRequestTask(MainActivity activity, GoogleAccountCredential credential) {

mActivity = activity;

HttpTransport transport = AndroidHttp.newCompatibleTransport();
JsonFactory jsonFactory = JacksonFactory.getDefaultInstance();

mService = new com.google.api.services.calendar.Calendar
.Builder(transport, jsonFactory, credential)
.setApplicationName("Google Calendar API Android Quickstart")
.build();
}

@Override
protected void onPreExecute() {
// mStatusText.setText("");
mProgress.show();
mStatusText.setText("데이터 가져오는 중...");
mResultText.setText("");
}

/*
* 백그라운드에서 Google Calendar API 호출 처리
*/
@Override
protected String doInBackground(Void... params) {
try {

if ( mID == 1) {

return createCalendar();

}else if (mID == 2) {

return addEvent();
}
else if (mID == 3) {

return getEvent();
}

} catch (Exception e) {
mLastError = e;
cancel(true);
return null;
}

return null;
}

/*
* CalendarTitle 이름의 캘린더에서 10개의 이벤트를 가져와 리턴
*/
private String getEvent() throws IOException {

DateTime now = new DateTime(System.currentTimeMillis());

String calendarID = getCalendarID("CalendarTitle");
if ( calendarID == null ){

return "캘린더를 먼저 생성하세요.";
}

Events events = mService.events().list(calendarID)//"primary")
.setMaxResults(10)
//.setTimeMin(now)
.setOrderBy("startTime")
.setSingleEvents(true)
.execute();
List<Event> items = events.getItems();

for (Event event : items) {

DateTime start = event.getStart().getDateTime();
if (start == null) {

// 모든 이벤트가 시작 시간을 갖고 있지는 않다. 그런 경우 시작 날짜만 사용
start = event.getStart().getDate();
}

eventStrings.add(String.format("%s \n (%s)", event.getSummary(), start));
}

return eventStrings.size() + "개의 데이터를 가져왔습니다.";
}

/*
* 선택되어 있는 Google 계정에 새 캘린더를 추가한다.
*/
private String createCalendar() throws IOException {

String ids = getCalendarID("CalendarTitle");

if ( ids != null ){

return "이미 캘린더가 생성되어 있습니다. ";
}

// 새로운 캘린더 생성
com.google.api.services.calendar.model.Calendar calendar = new Calendar();

// 캘린더의 제목 설정
calendar.setSummary("CalendarTitle");

// 캘린더의 시간대 설정
calendar.setTimeZone("Asia/Seoul");

// 구글 캘린더에 새로 만든 캘린더를 추가
Calendar createdCalendar = mService.calendars().insert(calendar).execute();

// 추가한 캘린더의 ID를 가져옴.
String calendarId = createdCalendar.getId();

// 구글 캘린더의 캘린더 목록에서 새로 만든 캘린더를 검색
CalendarListEntry calendarListEntry = mService.calendarList().get(calendarId).execute();

// 캘린더의 배경색을 파란색으로 표시 RGB
calendarListEntry.setBackgroundColor("#0000ff");

// 변경한 내용을 구글 캘린더에 반영
CalendarListEntry updatedCalendarListEntry =
mService.calendarList()
.update(calendarListEntry.getId(), calendarListEntry)
.setColorRgbFormat(true)
.execute();

// 새로 추가한 캘린더의 ID를 리턴
return "캘린더가 생성되었습니다.";
}

@Override
protected void onPostExecute(String output) {

mProgress.hide();
mStatusText.setText(output);

if ( mID == 3 ) mResultText.setText(TextUtils.join("\n\n", eventStrings));
}

@Override
protected void onCancelled() {
mProgress.hide();
if (mLastError != null) {
if (mLastError instanceof GooglePlayServicesAvailabilityIOException) {
showGooglePlayServicesAvailabilityErrorDialog(
((GooglePlayServicesAvailabilityIOException) mLastError)
.getConnectionStatusCode());
} else if (mLastError instanceof UserRecoverableAuthIOException) {
startActivityForResult(
((UserRecoverableAuthIOException) mLastError).getIntent(),
MainActivity.REQUEST_AUTHORIZATION);
} else {
mStatusText.setText("MakeRequestTask The following error occurred:\n" + mLastError.getMessage());
}
} else {
mStatusText.setText("요청 취소됨.");
}
}

private String addEvent() {

String calendarID = getCalendarID("CalendarTitle");

if ( calendarID == null ){

return "캘린더를 먼저 생성하세요.";

}

Event event = new Event()
.setSummary("구글 캘린더 테스트")
.setLocation("서울시")
.setDescription("캘린더에 이벤트 추가하는 것을 테스트합니다.");

java.util.Calendar calander;

calander = java.util.Calendar.getInstance();
SimpleDateFormat simpledateformat;
//simpledateformat = new SimpleDateFormat( "yyyy-MM-dd'T'HH:mm:ssZ", Locale.KOREA);
// Z에 대응하여 +0900이 입력되어 문제 생겨 수작업으로 입력
simpledateformat = new SimpleDateFormat( "yyyy-MM-dd'T'HH:mm:ss+09:00", Locale.KOREA);
String datetime = simpledateformat.format(calander.getTime());

DateTime startDateTime = new DateTime(datetime);
EventDateTime start = new EventDateTime()
.setDateTime(startDateTime)
.setTimeZone("Asia/Seoul");
event.setStart(start);

Log.d( "@@@", datetime );

DateTime endDateTime = new DateTime(datetime);
EventDateTime end = new EventDateTime()
.setDateTime(endDateTime)
.setTimeZone("Asia/Seoul");
event.setEnd(end);

//String[] recurrence = new String[]{"RRULE:FREQ=DAILY;COUNT=2"};
//event.setRecurrence(Arrays.asList(recurrence));

try {
event = mService.events().insert(calendarID, event).execute();
} catch (Exception e) {
e.printStackTrace();
Log.e("Exception", "Exception : " + e.toString());
}
System.out.printf("Event created: %s\n", event.getHtmlLink());
Log.e("Event", "created : " + event.getHtmlLink());
String eventStrings = "created : " + event.getHtmlLink();
return eventStrings;
}
}

}