자바는 세계적으로 매우 많이 이용되는 언어입니다. 

자바 : https://java.com/ko/ 

컴파일로 실행되는 언어이며 이용자가 많고 커뮤니티도 활발하여 자료가 많이 존재합니다. 스마트폰의 운영체제인 안드로이드가 기반으로 삼고 있는 언어이기도 합니다. 자바의 초급 단계로 계산기 역할을 하는 helloworld를 만들어보겠습니다.


1. helloworld.java

helloworld.java를 만들어 보겠습니다.

public class HelloWorld {
 
    public static void main(String[] args) {
 
        int a = 21;
        int b = 23;
        Integer insA = new Integer(21);
        Integer insB = new Integer(23);
        
        System.out.println("(bbb) int a: " + a + ", b: " + b);
        System.out.println("(bbb) Integer a: " + a + ", b: " + b);
        System.out.println();
        
        swap(a, b);
        swap(insA, insB);
        System.out.println();
        
        System.out.println("(aaa) int a: " + a + ", b: " + b);
        System.out.println("(aaa) Integer a: " + a + ", b: " + b);
    }
}
cs


int a 는 숫자 변수를 담는 자료형입니다. 그리고 System.out.println()은 괄호 안의 값을 출력하는 함수입니다. 계산 결과를 처리하여 출력하도록 설정했는데 위의 결과와 아래의 결과가 다릅니다. 왜냐하면 java는 아래의 swap같은 함수 처리를 해야 정확히 포인터를 계산해서 출력하기 때문입니다. 


2. swap 함수 작성

swap 함수를 따로 만들겠습니다.


    private static void swap(int a, int b){
        int tttaa = a;
        a = b;
        b = tttaa;
        System.out.println("(funn) int a: " + a + ", b: " + b);
    }
    private static void swap(Integer a, Integer b){
        Integer tttaa = new Integer(a);
        a = b;
        b = tttaa;
        System.out.println("(funn) Integer a: " + a + ", b: " + b);
    }
cs


이렇게 하면 함수를 만들게 됩니다. 스왑함수는 println을 포함합니다. 즉각적으로 바로 확인할 수 있게 하기 위해서입니다.

static void는 리턴되는 값이 없음을 의미합니다. 


3. 문자 입력받기

    private static int scanInt(){
        Scanner scn = new Scanner(System.in);
        int result = scn.nextInt();
        scn.close();
        return result;
    }
cs

그 다음 scanInt를 만들어서 숫자를 읽어들일 수 있도록 합니다. Scanner(System.in)은 키보드를 통한 입력을 받는 함수입니다. 자바에서 기본적으로 제공합니다.


public class Unknown1 {
    private int[] input;
    private int n;
    }
}
cs


이 함수를 통해 System.in을 한 번 살펴보겠습니다

.

    public Unknown1(){
        Scanner scnned = new Scanner(System.in);
         String[] array = scnned.nextLine().split(" ");
         input = new int[array.length];
         for(int i = 0; i < array.length; i++){
             input[i] = Integer.parseInt(array[i]);
         }
         scnned.close();
         
         n = input.length;
    }
cs


이 함수를 저기 위의 함수 안에 넣어주도록 합니다. ArrayList를 이용해서 주어진 숫자를 조작하는 함수입니다. 입력받는 인자는 여러번 연속적으로 주어질 수 있으므로 array 를 이용하여 작성합니다. 그러므로 for문을 이용해서 인자가 입력받을 때마다 array에 문자열을 입력하게 됩니다.


이번엔 GridLayout을 위한 adapter를 만들어보도록 하겠습니다. 그렇게 큰 차이는 없으나 이번엔 Retrofit를 이용한 통신까지 적용하겠습니다.


1. ViewHolder 지정


public class FlowerAdapter_grid extends RecyclerView.Adapter<FlowerAdapter_grid.Holder> {
 
    private static final Object TAG = FlowerAdapter_grid.class.getSimpleName();
    private final FlowerClickListener mListener;
    private List<Flower> mFlowers;
    public FlowerAdapter_grid(FlowerClickListener listener) {
        mFlowers = new ArrayList<>();
        mListener = listener;
    }
}
cs

GridLayout도 일종의 RecyclerView입니다. 그러므로 RecyclerView에서 GridLayout을 위한 뷰홀더를 작성할 것입니다. 그러기 위해선 ViewHolder의 extends가 필요합니다. 변수지정은 따로 언급하지 않겠습니다.


    @Override
    public Holder onCreateViewHolder(ViewGroup parent, int viewType) {
        View row = LayoutInflater.from(parent.getContext()).inflate(R.layout.row_item_grid, parent, false);
        return new Holder(row);
    }
cs

ViewHolder가 작성될 때 바로 layout에 적용될 수 있게 LayoutInflater.from(parent.getContext()).inflate(R.layout.row_item_grid, parent, false) 이 부분이 필요합니다. 그리고 지난시간에도 그랬듯이 ViewHolder처리 과정에서 Glide도 처리해줍니다. 

    @Override
    public void onBindViewHolder(Holder holder, int position) {
        Flower currFlower = mFlowers.get(position);
        Glide.with(holder.itemView.getContext())
                .load(currFlower.getImage())
                .thumbnail(0.5f)
                .crossFade()
                .into(holder.mImage);
    }
cs


이번엔 Glide를 thumbnail로 쓸 것입니다. 0.5f는 원본의 0.5만큼의 수준으로 thumbnail로 사용한다는 뜻입니다. crossfade()를 통해 애니메이션 효과도 부여할 수 있습니다.


    @Override
    public int getItemCount() {
        return mFlowers.size();
    }
 
    public void addFlower(Flower flower) {
        mFlowers.add(flower);
        notifyDataSetChanged();
    }
cs


이렇게 포스트의 사이즈를 가져오거나 새로운 포스트를 추가할 수 있습니다. 지난번과 코드가 동일합니다.


    public void clear(){
        mFlowers.clear();
        notifyDataSetChanged();
    }
 
    public Flower getSelectedFlower(int position) {
        return mFlowers.get(position);
    }
cs


포스트를 클리어할 때 사용됩니다. 지난번과 같은 코드입니다.


public class MyPagerAdapter extends FragmentPagerAdapter {
 
    public Fragment[] arrFragments;
    public MyPagerAdapter(FragmentManager fm, Fragment[] arrFragmnets) {
        super(fm);
        this.arrFragments = arrFragmnets;
    }
 
    @Override
    public Fragment getItem(int position) {
        return arrFragments[position];
    }
 
    @Override
    public int getCount() {
        return arrFragments.length;
    }
}
cs


이렇게 Fragment에 Adapter를 달아줍니다. 이제 여기선 apiservice도 작성할 것입니다. 위에선 Fragment getItem() 에서 arrFragments의 position 값을 return 합니다. 포스트의 수를 세기 위해 getCount()를 작성했습니다. arrFragments.length가 전체 포스트의 수를 반영합니다.


2. apiService 작성


public interface FlowerApiService {
 
    @GET("posts/")
    Call<List<Flower>> getAllFlowers(@Query("user_lat"String lat, @Query("user_lon"String lon);
}
cs


다른 apiservice 도 만들도록 합니다. apiService는 사전에 만들어둠으로써 나중에 retrofit 통신을 수월하게 해 줍니다. 포스트들의 위도와 경도값을 받는 apiservice를 만들겠습니다.


public interface LoginApiService {
 
    String string = "client_Id";
 
    @POST("rest-auth/login/")
    Call<MyKey> getget(@Body LoginData loginData);
}
cs

이것은 로그인을 위한 apiService입니다. 로그인시에 필요한 데이터를 받습니다. 어디로 데이터를 전송할지 url을 설정할 수 있습니다. 저는 @POST("rest-auth/login/")에서 나와있듯 host주소/rest-auth/login/으로 통신할 것입니다. 


public interface PostApiService {
 
    @Multipart
    @POST("posts/")
    Call<ResponseBody> uploadFile (@Part MultipartBody.Part part, @Part("point") RequestBody pointString, @Part("text") RequestBody textString);
}
cs


이 것은 포스트를 위한 apiService입니다. 이 것을 통해 글의 등록이 가능합니다. 주소가 바뀌었습니다. 위의 주소와 다른 주소로 통신합니다.

그 다음은 유저 등록을 위한 부분입니다. 유저 등록을 위한 주소가 따로 존재합니다.


public interface RegistrationApiService {
    @Multipart
    @POST("rest-auth/registration/")
    Call<ResponseBody> registersecond (@Part("username") RequestBody username, @Part("email") RequestBody email, @Part("password1") RequestBody password1, @Part("password2") RequestBody password2);
}
cs


유저 등록시에 비밀번호와 비밀번호 재확인을 위해 두 번 변수를 입력받기 때문에 @Part 부분이 여러개로 나눠져있습니다. 


3. REST Manager 작성

저는 서버와 클라이언트의 REST통신을 이용하고 있으므로 REST 통신을 위한 apiservice도 만들어주면 편리합니다.

서버에서 http요청의 header값을 살펴보게 되므로 그 header값을 자동으로 지정해주는 RestManager를 작성하겠습니다.



public class RestManager {
 
    static Context mContext;
 
    private FlowerApiService mFlowerApiService;
 
    public FlowerApiService getmFlowerApiService(Context context) {
        if (mFlowerApiService==null) {
 
            mContext = context;
 
            OkHttpClient client = new OkHttpClient();
            OkHttpClient.Builder builder = new OkHttpClient.Builder();
            builder.interceptors().add(new AddCookiesInterceptor(mContext));
            client = builder.build();
 
            Retrofit retrofit = new Retrofit.Builder()
                    .client(client)
                    .baseUrl(Constants.BASE_URL)
                    .addConverterFactory(GsonConverterFactory.create())
                    .build();
 
            mFlowerApiService = retrofit.create(FlowerApiService.class);
        }
 
        return mFlowerApiService;
    }
}
cs

이러면 자동으로 okhttpclient에 헤더와 바디를 추가해줍니다. 원하는 대로 원하는 값을 넣을 수 있으므로 필요하신 대로 작성하셔서 쓰면 됩니다. GsonConverterFactory는 구글에서 제공하는 json데이터 처리용 도구입니다. retrofit를 이용해서 통신을 할 때마다 쉽게 헤더를 조절할 수 있기에 여러가지 만들어두고 사용하시면 편리할 것입니다.


지난 포스트들에서 자주 사용된 Adapter를 설명하겠습니다. Adapter는 데이터 모델들을 원하는 상황에 적용할 수 있게 도와줍니다.


1. 준비물

먼저 만들었던 flower 모델이랑 flowerapi를 가져옵니다. post를 다루기 위한 모델과 api입니다. 덤으로 Glide도 가져옵니다. 여기서 Glide를 처리해 주어야합니다.


import com.bumptech.glide.Glide;
import com.example.keepair.myapplication.R;
import com.example.keepair.myapplication.model.Flower;
cs


2. Adapter ViewHolder 작성

그 다음에 Adapter랑 RecyclerView.Adapter를 만들어줍니다. RecyclerView를 사용하지 않는다면 다른 뷰를 extends 해도 괜찮습니다. Adapter에서 제공하는 Holder를 불러와서 사용합니다.


public class FlowerAdapter extends RecyclerView.Adapter<FlowerAdapter.Holder> {
}
cs

Adapter에 Holder를 붙여줘야 합니다. 그렇지 않으면 제대로 작동하지 않습니다.


    private static final Object TAG = FlowerAdapter.class.getSimpleName();
    private final FlowerClickListener mListener;
    private List<Flower> mFlowers;
cs


이렇게 변수를 지정해줍니다. getSimpleName()은 지난번에 설명한 글에 설명되어 있습니다.

http://codehanry.tistory.com/16 을 참고하시면 됩니다.


    public FlowerAdapter(FlowerClickListener listener) {
        mFlowers = new ArrayList<>();
        mListener = listener;
    }
cs


Adapter에 쓸 ArrayList를 만들도록 합니다. 포스트들의 양이 많으므로 추가하기 쉽게 ArrayList를 사용합니다.


    @Override
    public void onBindViewHolder(Holder holder, int position) {
 
        Flower currFlower = mFlowers.get(position);
 
        holder.mAuthor.setText(currFlower.getAuthor());
 
        holder.mText.setText(currFlower.getText());
        Glide.with(holder.itemView.getContext())
                .load(currFlower.getImage())
                .override(300300)
                .centerCrop()
                .into(holder.mImage);
    }
cs


여기서 뷰홀더를 작성합니다. 뷰홀더는 Adapter에서 Holder를 가져왔으므로 onBindViewHolder를 사용할 수 있게 되었습니다. position을 가져와서 currFlower에 넣어줍니다. position 값은 recyclerView에서의 포스트 위치를 의미하는 인자입니다. 글라이드 옵션도 조절할 수 있습니다. override()를 이용해 크기와 사진의 질을 조정합니다.


다음은 포스트를 클릭할 때의 기능을 구현합니다.


    public class Holder extends RecyclerView.ViewHolder implements View.OnClickListener {
 
        private ImageView mImage;
        private TextView mAuthor, mText;
 
        public Holder(View itemView) {
 
            super(itemView);
 
            mImage = (ImageView) itemView.findViewById(R.id.iv_photo);
            mAuthor = (TextView) itemView.findViewById(R.id.tv_author);
            mText = (TextView) itemView.findViewById(R.id.tv_text);
 
            itemView.setOnClickListener(this);
        }
    }
 
cs


RecyclerView에 결합시킬 것이므로 ViewHolder를 RecyclerView에서 가져오게 됩니다. implements를 통해 onClickListener를 구현하게 됩니다. 


        @Override
        public void onClick(View view) {
            mListener.onClick(getLayoutPosition());
        }
cs


이 부분을 추가해줘야 합니다. 그러면 클릭시에 Position을 가져오는 기능을 담당합니다. 이런 구조에서는 Position의 위치값이 중요하게 여겨집니다. 이게 글 번호를 의미한다고 생각해도 됩니다.


3. 포스트 세부설정 


    @Override
    public int getItemCount() {
        return mFlowers.size();
    }
 
    public void addFlower(Flower flower) {
        mFlowers.add(flower);
        notifyDataSetChanged();
    }
cs

여기서 포스트의 사이즈를 고르고 포스트의 추가를 결정합니다. 포스트의 추가는 자동적으로 이루어지게 됩니다. 앞서 설명한 infinite Scroll과 연관됩니다.


    public void clear(){
        mFlowers.clear();
        notifyDataSetChanged();
    }
 
    public Flower getSelectedFlower(int position) {
        return mFlowers.get(position);
    }
cs


여기서 clear()는 데이터에 변화가 있을 시에 작동합니다. 혹은 변화를 줄 시에 포스트들을 초기화하는 역할을 합니다.

    public interface FlowerClickListener {
        void onClick(int position);
    }

cs


포스트를 클릭했을 시에 위치값을 이용해 그 포스트에 관련한 동작을 수행하고 싶다면 작성합니다. interface를 통해 포스트에 추가적인 동작을 부여할 수 있습니다.

준비물

1. 우선 import해야 할 것들이 있습니다.

레이아웃에 필요한 위젯들을 가져옵니다.

import android.support.v4.widget.SwipeRefreshLayout;
import android.support.v7.widget.GridLayoutManager;
import android.support.v7.widget.LinearLayoutManager;
import android.support.v7.widget.RecyclerView;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
cs


이렇게 하면 GridLayoutManager 혹은 LinearLayoutManager를 통해 Activity를 조작할 수 있게 됩니다. 구글에서 제공하는 것이니 믿고 써도 됩니다.


2. 그 전에 만들어 놓은 Adapter들을 가져옵니다.

import com.example.keepair.myapplication.adapter.FlowerAdapter;
import com.example.keepair.myapplication.adapter.FlowerAdapter_grid;
cs


이것들은 나중에 설명할 것입니다. 지금은 여러 데이터들이 GridLayoutManager와 연동될 수 있도록 도와주는 역할을 한다고 알면 될 것 같습니다.


3. 레이아웃으로부터 값들을 가져옵니다.

화면에서 보여지는 것들의 값들을 가져올 필요가 있습니다.
RestManager는 따로 만든 것으로 나중에 다시 포스팅할 것입니다.

    private SwipeRefreshLayout swipeContainer_red;
    private RecyclerView mRecyclerView;
    private RestManager mRestManager;
    private FlowerAdapter_grid mFlowerAdapter;
    private TextView mCoordinatesTextGrid;
cs


2. 함수 작성

4. GridLayout을 위한 onCreateView를 구현합니다.

    @Nullable
    @Override
    public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
        View view = inflater.inflate(R.layout.fragment_red, container, false);
        swipeContainer_red = (SwipeRefreshLayout) view.findViewById(R.id.swipeContainer_red);
        setRetainInstance(true);
 
        mCoordinatesTextGrid = (TextView) view.findViewById(R.id.tv_coordinates_grid);
        getGridPosts();
        swipeContainer_red.setOnRefreshListener(new SwipeRefreshLayout.OnRefreshListener() {
            @Override
            public void onRefresh() {
                getGridPosts();
            }
        });
        configViews(view);
 
        return view;
    }
cs


OnCreateView를 통해 처음에 GridLayout을 불러올 시에 구성될 화면을 구현할 수 있습니다. SwifeRefreshLayout을 사용했습니다.

5. Posts를 가져올 함수를 지정합니다.

    private void getGridPosts() {
}

cs

이제 이 안에 글들을 가져와서 처리만 하면 됩니다.

6. 위에서 구현한 함수를 더 자세히 지정합니다.

위 getGridPosts() 안에 들어갈 내용입니다.

        ReferSharedPreference preferenceCoordinates = new ReferSharedPreference(getContext());
        String lat = preferenceCoordinates.getValue("Lat", "13");
        String lon = preferenceCoordinates.getValue("Lon", "15");
        mCoordinatesTextGrid.setText(lat + "  , " + lon);
        mRestManager = new RestManager();
        Call<List<Flower>> listCall = mRestManager.getmFlowerApiService(getActivity()).getAllFlowers(lat, lon);
        listCall.enqueue(new Callback<List<Flower>>() {
            @Override
            public void onResponse(Call<List<Flower>> call, Response<List<Flower>> response) {
                if (response.isSuccessful()) {
                    mFlowerAdapter.clear();
                    List<Flower> flowerList = response.body();
                    for(int i =0; i<flowerList.size(); i++) {
                        Flower flower = flowerList.get(i);
                        mFlowerAdapter.addFlower(flower);
                    }
                    swipeContainer_red.setRefreshing(false);
                }
            }
            @Override
            public void onFailure(Call<List<Flower>> call, Throwable t) {
            }
        });
cs


여기서 lat과 lon은 좌표값을 가져오는 것입니다. 이번에도 좌표값이 주어지지 않았다면 기본적으로 (13, 15) 좌표를 찾게 됩니다. 그런 다음 만들어놓은 ApiService를 이용해 비동기통신을 하여 그것을 Adapter를 이용해 추가하게 됩니다. Flower를 Post라고 생각하면 편합니다. 그 후 마지막으로 setRefreshing을 false로 설정해 자동적으로 새로고침을 반복하지 않도록 막아줍니다. 나머지 코드는 앞서 설명한 Retrofit의 Call함수입니다. 포스트에 FlowerList를 사용했습니다.


7. 환경설정을 조금만 더 해줍니다.

이렇게하면 RecyclerView의 여러가지 설정을 할 수 있습니다.

RecyclerView가 고정된 사이즈로 3개 항목을 한 줄에 나타내게끔 만들었습니다. 유행하는 스타일입니다.


    private void configViews(View view) {
        mRecyclerView = (RecyclerView) view.findViewById(R.id.rv_flower_red);
        mRecyclerView.setHasFixedSize(true);
        mRecyclerView.setRecycledViewPool(new RecyclerView.RecycledViewPool());
        mRecyclerView.setLayoutManager(new GridLayoutManager(getActivity().getApplicationContext(), 3));
        mFlowerAdapter = new FlowerAdapter_grid(this);
        mRecyclerView.setAdapter(mFlowerAdapter);
    }
cs

8. 포스트를 클릭했을 때의 이벤트를 설정합니다.

    @Override
    public void onClick(int position) {
        Flower selectedFlower = mFlowerAdapter.getSelectedFlower(position);
        Intent intent = new Intent(getContext(), DetailActivity.class);
        intent.putExtra(Constants.REFERENCE.FLOWER, selectedFlower);
        startActivity(intent);
    }
cs



이렇게하면 GridLayout Fragment를 완성합니다. 마지막에 intent로 포스트 클릭시에 DetailActivity 가 실행되도록 했습니다. DetailActivy는 다음에 알아보겠습니다.

1. 준비물

이번엔 register 기능을 구현할 것입니다.

먼저 몇가지를 import하겠습니다. 그 중 okhttp3의 mediatype을 이용할 것입니다. 나머지는 유저 등록을 위한 모델들입니다.


import com.example.keepair.myapplication.apiservice.RegistrationApiService;
import com.example.keepair.myapplication.helper.Constants;
import com.example.keepair.myapplication.loginhelper.ReferSharedPreference;
import com.example.keepair.myapplication.model.MyKey;
 
import okhttp3.MediaType;
cs


이렇게 하면 requestBody를 따로 만들 수 있게 됩니다. okhttp의 requestBody를 만들기 위해 MediaType이 필요합니다. request의 POST 요청을 위해 사용하는 것입니다.


필요한 정보를 가져옵니다. 저장되어있는 정보도 괜찮고 새로 불러올 정보도 괜찮습니다.


    MyKey keygoven;
 
    RegistrationApiService mRegistrationApiService;
    EditText mUsernameRegistrationEditText;
    EditText mPasswordRegistration1EditText;
    EditText mPasswordRegistration2EditText;
    ImageView mRegisterButton;
    RelativeLayout mLayoutRegstration;
 
    ReferSharedPreference mSavedUserInfo;
cs


저는 SharedPreference 의 변형인 ReferSharedPreference를 쓸 것입니다.


2. 함수 구현

그 다음 onCreate를 작성합니다.


    @Override
    protected void onCreate(Bundle savedInstanceState) {
    }
cs


여기 안에 필요한 코드들을 넣겠습니다.


        super.onCreate(savedInstanceState);
        requestWindowFeature(Window.FEATURE_NO_TITLE);
        setContentView(R.layout.activity_registration);
        Display display = ((WindowManager) getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay();
        int width = (int) (display.getWidth() * 0.999); //Display 사이즈
        int height = (int) (display.getHeight() * 0.9);  //Display 사이즈
        getWindow().getAttributes().width = width;
        getWindow().getAttributes().height = height;
cs


이렇게 하면 기본 Activity의 사이즈를 정하게 됩니다. display 되는 사이즈라고 생각하면 됩니다. 안드로이드 화면의 크기를 조절하는 것입니다. getWidth()와 getHeight()를 사용했습니다. 지난 포스트에서는 0.7과 0.9를 사용했지만 이번엔 최대 크기를 잡기 위해 비율을 1에 가깝게 했습니다.


그 다음 레이아웃과 저장된 SharedPreference로부터 값을 불러와서 사용될 값으로 넣어주겠습니다.


        mSavedUserInfo = new ReferSharedPreference(getApplicationContext());
        mUsernameRegistrationEditText = (EditText) findViewById(R.id.et_username_registration);
        mPasswordRegistration1EditText = (EditText) findViewById(R.id.et_password_registration_1);
        mPasswordRegistration2EditText = (EditText) findViewById(R.id.et_password_registration_2);
        mRegisterButton = (ImageView) findViewById(R.id.btn_registration);
        mLayoutRegstration = (RelativeLayout) findViewById(R.id.layoutRegistration);
cs


유저 등록에 필요한 정보들은 모두 가져오게 되었습니다. 그 다음엔 이걸 POST요청으로 전송할 수 있게 onClickListener()를 작성합니다.


                final String givenRegistrationUserName = mUsernameRegistrationEditText.getText().toString();
                final String givenRegistrationPassword1 = mPasswordRegistration1EditText.getText().toString();
                String givenRegistrationPassword2 = mPasswordRegistration2EditText.getText().toString();
                String givenEmail = "";
cs


쓸 값들을 변수에 넣어서 준비합니다. okhttp client에서 사용될 것입니다.

그 다음엔 조건에 맞는다면 전송하는 부분을 작성합니다. 항상 등록을 허가할 순 없으니 조건을 구성합니다. if문을 사용했습니다.


                if(givenRegistrationUserName.length() >= 3){
                    if(givenRegistrationPassword1.equals(givenRegistrationPassword2)){
                    }
                }
cs


username의 길이와 password의 일치여부를 확인한 후 둘 다 True면 실행되는 코드입니다.


                            OkHttpClient client = new OkHttpClient();
                            OkHttpClient.Builder builder = new OkHttpClient.Builder();
                            client = builder.build();
 
                            Retrofit retrofit = new Retrofit.Builder()
                                    .client(client)
                                    .addConverterFactory(GsonConverterFactory.create())
                                    .baseUrl(Constants.BASE_URL)
                                    .build();
 
                            mRegistrationApiService = retrofit.create(RegistrationApiService.class);
 
cs


Api Client를 만듭니다. 그리고 request 보내기 전 데이터를 수집합니다. Retrofit가 편리하게 사용됩니다.


                            RequestBody username =
                                    RequestBody.create(
                                            MediaType.parse("multipart/form-data"), givenRegistrationUserName);
                            RequestBody email =
                                    RequestBody.create(
                                            MediaType.parse("multipart/form-data"), givenEmail);
                            RequestBody password1 =
                                    RequestBody.create(
                                            MediaType.parse("multipart/form-data"), givenRegistrationPassword1);
                            RequestBody password2 =
                                    RequestBody.create(
                                            MediaType.parse("multipart/form-data"), givenRegistrationPassword2);
cs


사용자가 입력한 정보를 RequestBody에 넣어 서버로 전송할 것입니다. 이렇게 하면 requestBody 구성이 완료됩니다.

이제 직접 서버와 통신하는 부분을 작성하겠습니다. 지난 시간의 Call 요청을 좀 더 자세하게 구현합니다.


 
                            Call<ResponseBody> call = mRegistrationApiService.registersecond(username, email, password1, password2);
                            call.enqueue(new Callback<ResponseBody>() {
                                @Override
                                public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
                                    if (response.isSuccessful()){
                                        Toast.makeText(getApplicationContext(), "Success", Toast.LENGTH_LONG).show();
                                        mSavedUserInfo.put("SavedUserName", givenRegistrationUserName);
                                        mSavedUserInfo.put("SavedPassword", givenRegistrationPassword1);
                                        Intent intent = new Intent(RegistrationActivity.this, LoginActivity.class);
                                        intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK);
                                        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                                        startActivity(intent);
                                    }
                                    else {
                                        Toast.makeText(getApplicationContext(), "Something wrong, Would you check password conditions?", Toast.LENGTH_LONG).show();
                                    }
                                }
 
                                @Override
                                public void onFailure(Call<ResponseBody> call, Throwable t) {
 
                                }
                            });
cs


이렇게하여 Retrofit의 Call도 구현했습니다. 유저 등록이 끝나면 다시 LoginActivity로 이동하도록 intent를 만들었습니다. intent에서 현재의 activity를 효과적으로 제거할 수 있게 FLAG들을 사용했습니다.


이 다음엔 failure를 구현하면 됩니다. 위에선 response에서의 response.isSuccessful() 과 else가 있고 따로 onFailure()가 존재하지만 원하는 대로 작성하시면 됩니다.

여러 앱에서 필수적인 기능인 로그인 기능을 구현하겠습니다. 버터나이프라는 좋은 모듈을 사용할 것입니다. 버터나이프는 안드로이드에서 view에 쉽게 접근할 수 있게 해 줍니다. 

butterknife : http://jakewharton.github.io/butterknife/


1. 레이아웃 불러오기

먼저 레이아웃에서 로그인 아이디값, 비밀번호값 등을 가져오기 전에 그 값들을 저장할 데이터 모델과 그 모델을 처리할 apiService를 불러오겠습니다.


import com.example.keepair.myapplication.apiservice.LoginApiService;
import com.example.keepair.myapplication.helper.Constants;
import com.example.keepair.myapplication.loginhelper.ReferSharedPreference;
import com.example.keepair.myapplication.model.LoginData;
import com.example.keepair.myapplication.model.MyKey;
cs

여기서 ReferSharedPreference는 나중에 살펴볼 것입니다. 지금은 자동 로그인을 위한 SharedPreference 라고 알고 넘어가면 될 것 같습니다. SharedPreference는 안드로이드에서 유용하게 사용되는 저장 도구입니다. 앞서 말한대로 버터나이프 모듈을 쓸 것이니 그것도 가져와줍니다.


import butterknife.Bind;
import butterknife.ButterKnife;
import butterknife.OnClick;
cs

그 다음 값을 담을 변수들을 정합니다.


    MyKey keygiven;
    LoginApiService loginApiService;
    @Bind(R.id.usernameTextField)
    EditText mUsernameTextField;
    @Bind(R.id.passwordTextField)
    EditText mPasswordTextField;
    @Bind(R.id.loginButton)
    ImageView mLoginButton;
    @Bind(R.id.btn_start_RegistrationActivity)
    ImageView mStartRegistrationButton;
    @Bind(R.id.layout_Login)
    RelativeLayout mLayoutLogin;
    ReferSharedPreference mSavedUserInfo;
cs

@Bind가 butterknife의 역할입니다. @Bind를 통해 길던 코드가 매우 짧아졌습니다. butterknife를 쓰는 사람들은 이 간결함을 선호합니다.


2. 함수 지정

onCreate를 설정하겠습니다. onCreate는 생성될 때의 옵션을 의미합니다. 화면이 만들어질 때부터 기능할 수 있는 부분을 정하게 됩니다.


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_login);
        ButterKnife.bind(this);
 
        mSavedUserInfo = new ReferSharedPreference(getApplicationContext());
 
        mUsernameTextField.setText(mSavedUserInfo.getValue("SavedUserName"""));
        mPasswordTextField.setText(mSavedUserInfo.getValue("SavedPassword"""));
    }
cs

mSavedUserInfo가 없다면 새로운 값을 가져오게 되는 것입니다. 새로운 값을 가져올 때는 레이아웃에서 값을 가져와보고, 레이아웃에서 값이 존재하지 않는다면 "" 값을 가져옵니다. 빈 텍스트를 가져오게 됩니다. 저장된 값들은 SharedPreference에서 존재합니다.

 

등록 버튼을 눌렀을 때 새로운 RegisterActivity가 생성되도록 intent를 만들겠습니다.

로그인 화면이 있고 로그인 화면에서 등록 버튼을 눌러 사용자 등록을 위한 화면을 생성하는 구조입니다.


    @OnClick(R.id.btn_start_RegistrationActivity)
    public void onClickToStartRegistration(View view){
        Intent intent = new Intent(LoginActivity.this, RegistrationActivity.class);
        startActivity(intent);
    }
cs

로그인 버튼을 구현합니다. @onClick을 butterknife를 이용해 만듭니다. @onClick도 butterknife에서 제공되는 유용한 도구입니다.


    @OnClick(R.id.loginButton)
    public void onClick(View view) {
    }
cs

이제 여기 안에 내용을 채우면 됩니다.

우선 사용자가 작성한 값들을 레이아웃으로부터 가져옵니다.


        final String givenUserName = mUsernameTextField.getText().toString();
        String givenEmail = "";
        final String givenPassword = mPasswordTextField.getText().toString();
        LoginData loginData = new LoginData(givenUserName, givenPassword, givenEmail);
cs


Okhttp3를 이용해서 로깅을 조절합니다. header랑 body를 지정합니다. 이걸 통해 http가 어떻게 통신되는지 확인할 수 있습니다.


        HttpLoggingInterceptor logging = new HttpLoggingInterceptor();
        logging.setLevel(HttpLoggingInterceptor.Level.BODY);
        logging.setLevel(HttpLoggingInterceptor.Level.HEADERS);
 
cs

로그인에 이용할 Retrofit을 불러올 것입니다.  Retrofit는 나중에 살펴볼 비동기 통신 도구입니다. 사전작업을 하겠습니다.

client라는 변수에 okHttpClient() 값을 넣어줍니다.


        OkHttpClient client = new OkHttpClient();
        OkHttpClient.Builder builder = new OkHttpClient.Builder();
        builder.interceptors().add(logging);
 
        client = builder.build();
 
        Retrofit retrofit = new Retrofit.Builder()
                .client(client)
                .addConverterFactory(GsonConverterFactory.create())
                .baseUrl(Constants.BASE_URL)
                .build();
cs


이제 직접적으로 서버와 통신할 Call부분을 만듭니다.

Call부분은 이렇게 성공한 경우와 실패한 경우를 나눠서 대응할 수 있습니다. 서버와의 통신에 성공하면 response.isSuccessful()이 호출되고 그렇지 않다면 onFailure()가 호출될 것입니다.

 
        loginApiService = retrofit.create(LoginApiService.class);
        Call<MyKey> getget = loginApiService.getget(loginData);
        getget.enqueue(new Callback<MyKey>() {
            @Override
            public void onResponse(Call<MyKey> call, Response<MyKey> response) {
                if (response.isSuccessful()) {
                }
                else {
                    Toast.makeText(getApplicationContext(),"Failed", Toast.LENGTH_LONG).show();
                }
            }
            @Override
            public void onFailure(Call<MyKey> call, Throwable t) {
            }
        });
cs

실패한다면 별 반응이 없어도 되지만 성공한다면 로그인 이후의 반응을 작성해야합니다.


                    keygiven = response.body();
 
                    Toast.makeText(getApplicationContext(),"We waited you, " + givenUserName, Toast.LENGTH_LONG).show();
 
                    mSavedUserInfo.put("SavedUserName", givenUserName);
                    mSavedUserInfo.put("SavedPassword", givenPassword);
 
                    ReferSharedPreference givenToken = new ReferSharedPreference(getApplicationContext());
                    givenToken.put("Token""Token "+ keygiven.getKey());
                    Intent intent = new Intent(LoginActivity.this, MainActivity.class);
                    intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK);
                    intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                    startActivity(intent);
cs


이렇게 하면 통신에 성공했을 때 로그인을 하여 startActivity를 실행하게 됩니다.

실패하게 되면 간단히 Toast만 띄워줍니다.


                    Toast.makeText(getApplicationContext(),"Failed", Toast.LENGTH_LONG).show();
cs


LoginActivity를 간단하게 만들어 보았습니다.

1. Infinite Scroll이란

Infinite Scroll은 무한스크롤, 즉 유튜브나 페이스북, 트위터 등에서 스크롤이 끊임없이 이어지는 것을 말합니다.
브라우저 같은 경우 자바스크립트로 구현할 수 있겠고 안드로이드도 그런 식으로 만드는 것이 가능하겠으나 많이 사용되고 있으므로 여러가지 툴이 존재합니다. 그 중 구글이 제공하는 Recycler View를 이용해서 만들어보겠습니다.

2. Recycler View 이용


우선 Recycler View 라고 구글에서 제공해주는 좋은 재료가 있습니다.


import android.support.v7.widget.RecyclerView;
cs


그 다음 Listener를 달아줍니다.


public abstract class EndlessScrollListener extends RecyclerView.OnScrollListener {
}
cs


이렇게 RecyclerView.onScrollListener를 extends하여 구현합니다.

여기에 작업을 해주면 됩니다. 세부적인 옵션을 설정하겠습니다.


    private int visibleThreshold = 2;
    private int currentPage = 1;
    private int previousTotalItemCount = 0;
    private boolean loading = true;
    private int startingPageIndex = 1;
    private RecyclerView.LayoutManager mLayoutManager;
cs


변수의 이름대로 옵션을 설정했습니다.

그 다음엔 Scroll에 필요한 Listener를 등록하기 위해 layoutManager를 작성합니다.


    protected EndlessScrollListener(LinearLayoutManager layoutManager) {
        this.mLayoutManager = layoutManager;
    }
    
    public EndlessScrollListener(GridLayoutManager layoutManager) {
        this.mLayoutManager = layoutManager;
        visibleThreshold = visibleThreshold * layoutManager.getSpanCount();
    }
    
    public EndlessScrollListener(StaggeredGridLayoutManager layoutManager) {
        this.mLayoutManager = layoutManager;
        visibleThreshold = visibleThreshold * layoutManager.getSpanCount();
    }
cs

이렇게 여러가지 매니저를 처리하도록 합니다. visibleThreshold와 layoutManager의 getSpanCount()를 이용해서 visibleThreshold에 다시 값을 지정합니다.


그 다음 스크롤 후 마지막 항목 차례에서 벌어질 이벤트를 처리합니다. 이 부분을 통해 무한으로 스크롤되는 유저 경험을 제공합니다. 마지막으로 보이게 되는 아이템과 그 아이템의 위치를 이용해서 for 문을 구성하고 maxSize 변수에 값을 넣어 이벤트를 만들 것입니다.


    @Contract(pure = true)
    private int getLastVisibleItem(int[] lastVisibleItemPositions) {
        int maxSize = 0;
        for (int i = 0; i < lastVisibleItemPositions.length; i++) {
            if (i == 0) {
                maxSize = lastVisibleItemPositions[i];
            } else if (lastVisibleItemPositions[i] > maxSize) {
                maxSize = lastVisibleItemPositions[i];
            }
        }
        return maxSize;
    }
cs


3. 마지막 항목에서의 이벤트

마지막 항목까지 스크롤 되었을 때의 이벤트를 조금 더 세부적으로 설정합니다. lastVisibleItemPosition 변수를 만들어서 처리합니다.


    @Override
    public void onScrolled(RecyclerView view, int dx, int dy) {
        int lastVisibleItemPosition = 0;
        int totalItemCount = mLayoutManager.getItemCount();
        
        if (mLayoutManager instanceof StaggeredGridLayoutManager) {
            int[] lastVisibleItemPositions = ((StaggeredGridLayoutManager) mLayoutManager).findLastVisibleItemPositions(null);
            // get maximum element within the list
            lastVisibleItemPosition = getLastVisibleItem(lastVisibleItemPositions);
        } else if (mLayoutManager instanceof GridLayoutManager) {
            lastVisibleItemPosition = ((GridLayoutManager) mLayoutManager).findLastVisibleItemPosition();
        } else if (mLayoutManager instanceof LinearLayoutManager) {
            lastVisibleItemPosition = ((LinearLayoutManager) mLayoutManager).findLastVisibleItemPosition();
        }
        
        if (totalItemCount < previousTotalItemCount) {
            this.currentPage = this.startingPageIndex;
            this.previousTotalItemCount = totalItemCount;
            if (totalItemCount == 0) {
                this.loading = true;
            }
        }
        if (loading && (totalItemCount > previousTotalItemCount)) {
            loading = false;
            previousTotalItemCount = totalItemCount;
        }
        if (!loading && (lastVisibleItemPosition + visibleThreshold) > totalItemCount) {
            currentPage++;
            onLoadMore(currentPage, totalItemCount, view);
            loading = true;
        }
    }
cs


이렇게 한 후엔 스크롤이 반복적으로 reset될 state를 설정하면 됩니다.


    public void resetState() {
        this.currentPage = this.startingPageIndex;
        this.previousTotalItemCount = 0;
        this.loading = true;
    }
 
cs


그 다음에 마무리로 더 불러오기를 구현합니다. 여러가지 처리를 한 끝에 자동적으로 스크롤할 콘텐츠를 불러오게 됩니다. 사용자는 끊임없이 스크롤되는 것처럼 느끼게 됩니다.


    public abstract void onLoadMore(int page, int totalItemsCount, RecyclerView view);
cs


이렇게 끝맺을 수 있습니다.

지난 포스트에서 비율을 정하는 부분이 있었습니다.


        int width = opts.outWidth;
        int height = opts.outHeight;
 
        float sampleRatio = getSampleRatio(width, height);
cs


이 부분을 더 자세히 알아보겠습니다. getSampleRatio는 width와 height 값을 받는 함수입니다. java에서 기본으로 제공하는 함수가 아니므로 설명이 더 필요합니다.


1. getSampleRatio() 


    private float getSampleRatio(int width, int height) {
    }
cs


이 함수를 채워넣을 것입니다.


        final int targetWidth = 1280;
        final int targetheight = 1280;
        float ratio;
cs


우선 이렇게 인자를 형성합니다. 흔히 확인할 수 있는 화면 해상도인 1280 * 720 에서의 1280 입니다.


        if (width > height) {
            // 가로
            if (width > targetWidth) {
                ratio = (float) width / (float) targetWidth;
            } else ratio = 1f;
        } else {
            // 세로
            if (height > targetheight) {
                ratio = (float) height / (float) targetheight;
            } else ratio = 1f;
        }
cs


이렇게 가로와 세로의 경우의 수를 따져줍니다. 모바일 화면이니 1280이 그 기준이 됩니다.


    private File createFileFromBitmap(Bitmap bitmap) throws IOException {
        File newFile = new File(getActivity().getFilesDir(), makeImageFileName());
        FileOutputStream fileOutputStream = new FileOutputStream(newFile);
        bitmap.compress(Bitmap.CompressFormat.PNG, 100, fileOutputStream);
        fileOutputStream.close();
        return newFile;
    }
cs


이렇게 File에다가 Bitmap을 이용해서 함수를 만들어줍니다. getSampleRatio는 단순히 비율만을 결정하므로 파일을 가져와주는 과정이 필요합니다. FileOutPutStram(newFile)을 이용한 다음에 주어진 비트맵을 편집할 수 있도록 bitmap.compress를 사용해줍니다.


2. makeImageFileName()


    private String makeImageFileName() {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyyMMdd_hhmmss");
        Date date = new Date();
        String strDate = simpleDateFormat.format(date);
        return strDate + ".png";
    }
cs


여기서 FileName을 설정해줄 수 있습니다. format도 정해줄 수 있습니다. 이름을 정함과 동시에 포맷까지 결정하는 함수입니다. 이미지파일을 다룰 것이므로 png 확장자를 사용했습니다. SimpleDateFormat은 java에서 제공해줍니다.


import java.text.SimpleDateFormat;
import java.util.Date;
cs


이걸 이용하면 됩니다. 날짜 관련 자료들을 텍스트나 원하는 형식으로 편집할 때 유용하게 쓰입니다.

1. 준비물 

Bitmap을 이용할 것입니다. 그러므로 Bitmap관련 모듈들을 import하고 getBitmapFromUri를 새로 만듭니다.


1
2
3
4
5
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.net.Uri;  
      private Bitmap getBitmapFromUri(Uri uri) throws IOException {
    }
cs


그 다음에 FileDescriptor를 import 하고 새로 FileDescriptor를 써 줍니다.


1
2
3
4
5
6
import java.io.FileDescriptor;
import java.io.FileOutputStream;
import java.io.IOException;
        ParcelFileDescriptor parcelFileDescriptor =
                getActivity().getContentResolver().openFileDescriptor(uri, "r");
        FileDescriptor fileDescriptor = parcelFileDescriptor.getFileDescriptor();
cs


2. 비트맵 파일 편집


파일을 가져온 다음엔 BitmapFactory를 이용해서 세부 옵션을 설정합니다.


        BitmapFactory.Options opts = new BitmapFactory.Options();
        opts.inJustDecodeBounds = true;
        BitmapFactory.decodeFileDescriptor(fileDescriptor, null, opts);
cs


옵션은 따로 정해줄 수 있습니다.


        int width = opts.outWidth;
        int height = opts.outHeight;
 
        float sampleRatio = getSampleRatio(width, height);
 
        opts.inJustDecodeBounds = false;
        opts.inSampleSize = (int) sampleRatio;
 
cs


그 후에 Bitmap 스트림을 닫아줍니다.


        Bitmap resizedBitmap = BitmapFactory.decodeFileDescriptor(fileDescriptor, null, opts);
        Log.d("Resizing", "Resized Width / Height : " + resizedBitmap.getWidth() + "/" + resizedBitmap.getHeight());
        parcelFileDescriptor.close();
        return resizedBitmap;
cs


3. 이미지 파일에 부여될 텍스트 편집

Bitmap으로 불러온 파일에 이름을 지정할 것이므로 아래의 코드를 activity에서 원하는 자리에 위치시킵니다. 부모레이아웃과 자식레이아웃을 설정해서 작업해봤습니다.


    public void onAddField(View v) {
        LayoutInflater inflater = (LayoutInflater) getSystemService(Context.LAYOUT_INFLATER_SERVICE);
        final View rowView = inflater.inflate(R.layout.field, null);
        parentLinearLayout.addView(rowView, parentLinearLayout.getChildCount());
        int count = parentLinearLayout.getChildCount();
        TextView result_field = findViewById(R.id.result);
        result_field.setText(Integer.toString((count-1)));
        View view = parentLinearLayout.getChildAt(count-1);
        if(view instanceof EditText){
            EditText last = (EditText)view;
            last.setSelection(0);
        }
    }
cs


그 다음 이름을 사용자로부터 받은 후 등록여부를 재차 확인하는 버튼을 구현합니다.


    @Override
    public void onBackPressed() {
        AlertDialog.Builder builder = new AlertDialog.Builder(this);
        builder.setTitle("You can Save your title");
        builder.setMessage("re-check your message?");
        builder.setPositiveButton("Enter"new DialogInterface.OnClickListener() {
            public void onClick(DialogInterface dialog, int which) {
                dialog.dismiss();
                finish();
            }
        });
        builder.setNegativeButton("Deny"new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                dialog.dismiss();
            }
        });
        AlertDialog alert = builder.create();
        alert.show();
    }
}
cs


이렇게 긍정 버튼과 부정 버튼을 설정했습니다. 사용자가 Enter와 Deny 둘 중 하나를 선택하여 이름을 지정할 수 있습니다.

1. 준비물

Dialog를 사용할 것입니다. Dialog를 위해 이런 코드를 써야 합니다.


import android.content.DialogInterface;
import android.content.Intent;
 
import android.support.v4.content.ContextCompat;
import android.support.v7.app.AlertDialog;
import android.support.v7.app.AppCompatDialogFragment;    
 
    private void openDialog() {
    }
cs


이렇게 하면 Dialog가 열립니다.

Dialog 안에도 inflater를 써서 콘텐츠를 가져옵니다.


        LayoutInflater inflater = LayoutInflater.from(getContext());
        View subView = inflater.inflate(R.layout.dialog_layout, null);
cs


View도 가져옵니다. View를 가져올 시엔 inflater를 사용합니다. getContext()는 액티비티의 속성을 가져오기 위해 사용합니다.


        final EditText subEditText = (EditText) subView.findViewById(R.id.dialogEditText);
 
cs


EditText는 유저가 할 말을 전달하는 역할을 수행합니다.


그 외 기타 코드들 입니다.


        subEditText.setSelection(subEditText.length());
        AlertDialog.Builder builder = new AlertDialog.Builder(new ContextThemeWrapper(getContext(), R.style.myDialog));
        builder.setTitle("Text to Post");
        builder.setView(subView);
        AlertDialog alertDialog = builder.create();
cs


Dialog는 builder로 create()해줘야 합니다.


2. 긍정, 부정 버튼

긍정 버튼은 이렇게 구현합니다.


        builder.setPositiveButton("Ok", new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialogInterface, int i) {
                mEditTextdialogOpenField.setText(subEditText.getText().toString());
            }
        });
cs


이러면 긍정적으로 버튼이 작동합니다. 질문에 긍정적으로 답했을 때 코드들이 실행되는 구조입니다.

반대로 부정 버튼은 이렇게 합니다.


        builder.setNegativeButton("Cancel"new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialogInterface, int i) {
                Snackbar.make(getView(), "Cancel", Snackbar.LENGTH_LONG).show();
            }
        });
cs


이러면 버튼이 부정적으로 동작하게 됩니다.


        builder.show();
 
cs


애써 만든 코드에 show()를 더해줘야 정상적으로 동작합니다.

+ Recent posts