Ship an update to your Android app with Couchbase Mobile

Android 공개 베타 테스트 및 iOS용 테스트플라이트와 같은 새로운 도구를 통해 네이티브 모바일 애플리케이션의 새로운 업데이트를 더 정기적으로 출시하는 것이 점점 더 증가하는 추세입니다.

비즈니스 로직과 데이터 모델을 더 정기적으로 변경하는 것 외에도 이전 버전을 지원해야 할 필요성도 있습니다. 사용자가 항상 브라우저에서 최신 버전에 액세스하는 웹사이트와 달리 모바일 앱은 업데이트 없이 사용자의 디바이스에 오랫동안 남아 있을 수 있습니다.

이 튜토리얼에서는 카우치베이스 모바일로 안드로이드 앱에 업데이트를 배포하는 방법을 배웁니다. 동기화 게이트웨이 웹훅을 사용하여 필요에 따라 타사 API(이 경우 Google Places API)에서 Node.js로 데이터를 가져옵니다. 첫 번째 인스턴스에서는 Android 앱이 모든 데이터를 동기화하고 이후 버전의 앱에서는 그 중 일부만 가져옵니다. 동기화 기능에서 액세스 규칙을 변경하면 동기화 게이트웨이를 사용하게 됩니다. 재동기화 작업을 수행하여 업데이트된 동기화 기능에 따라 액세스 규칙을 다시 작성합니다.

시작해보자!

다양한 구성 요소를 조합하는 순서는 다음과 같습니다:

동기화 게이트웨이 설치
웹훅 구성하기
앱 서버 구축
Android 앱 빌드

시작하기

동기화 게이트웨이를 다운로드하고 파일의 압축을 풉니다:

http://www.couchbase.com/nosql-databases/downloads#Couchbase_Mobile

동기화 게이트웨이 바이너리는 다음에서 찾을 수 있습니다. bin 폴더에 있는 구성 파일의 예와 예제 폴더로 이동합니다. 폴더를 복사합니다. basic-walrus-bucket.json 파일을 프로젝트의 루트에 추가합니다:

$ cp /Downloads/couchbase-sync-gateway/examples/basic-walrus-bucket.json /path/to/proj/sync-gateway-config.json

1	$ cp /다운로드/카우치베이스-동기화-게이트웨이/예제/기본-바다코끼리-버킷.json /경로/에/프로젝트/동기화-게이트웨이-구성.json

동기화 게이트웨이를 시작합니다:

$ ~/Downloads/couchbase-sync-gateway/bin/sync_gateway

1	$ ~/다운로드/카우치베이스-동기화-게이트웨이/bin/동기화 게이트웨이

동기화 게이트웨이 웹훅

웹후크는 위에서 만든 구성 파일에 정의되어 있으며 다음과 같이 URL 에 POST하고 필터 기능 (선택 사항). 추가 이벤트 핸들러 필드에 동기화 게이트웨이-config.json 를 다음과 같은 속성으로 설정합니다:

{
  "log": ["*"],
  "databases": {
    "db": {
      "bucket": "default",
      "server": "http://localhost:8091",
      "users": { "GUEST": { "disabled": false, "admin_channels": ["*"] } },
      "event_handlers": {
        "document_changed": [
          {
            "handler": "webhook",
            "url": "http://localhost:8000/sync_request",
            "filter": `function(doc) {
              if (doc.type == "profile") {
                return true;
              }
              return false;
            }`
          }
        ]
      }
    }
  }
}

{

"log": ["*"],

"데이터베이스": {

"db": {

"bucket": "default",

"서버": "http://localhost:8091",

"users": { "GUEST": { "disabled": false, "admin_channels": ["*"] } },

"event_handlers": {

"문서_변경": [

{

"핸들러": "웹훅",

"url": "http://localhost:8000/sync_request",

"filter": `함수(doc) {

만약 (doc.유형 == "프로필") {

반환 true;

}

반환 false;

}

]

}

각 새 필드의 기능은 다음과 같습니다:

핸들러: 이벤트 유형을 다음과 같이 지정하고 있습니다. 웹훅
URL: 메시지 본문에 문서와 함께 POST 요청을 보낼 URL입니다.
필터: 웹훅이 반환되는 경우에만 트리거하도록 자바스크립트로 작성된 함수입니다. true. 여기서 웹후크는 문서에 유형 속성은 프로필

변경 사항을 저장하고 동기화 게이트웨이를 다시 시작합니다:

$ ~/Downloads/couchbase-sync-gateway/bin/sync_gateway ./sync-gateway-config.json

1	$ ~/다운로드/카우치베이스-동기화-게이트웨이/bin/동기화_게이트웨이 ./동기화-게이트웨이-구성.json

앱 서버

이 섹션에서는 웹훅을 처리할 앱 서버를 설정하기 위해 Node.js와 Express 프레임워크를 사용합니다. 같은 디렉토리에 필요한 Node.js 모듈을 설치합니다:

npm install express body-parser --save

1	npm 설치 express body-파서 --저장

라는 새 파일에서 server.js 다음 코드를 추가합니다:

var express = require('express');
var bodyParser = require('body-parser');
var app = express();
app.use(bodyParser.json());

/**
 * Handle the Sync Gateway webhook request.
 * The request body contains the document.
 */
app.post('/sync_request', function (req, res) {
  var document = req.body;
  console.log('Handle webhook with doc :: %s', JSON.stringify(document));
  res.sendStatus(200);
});

var server = app.listen(8000, function () {
  var host = server.address().address;
  var port = server.address().port;

  console.log('App listening at http://%s:%s', host, port);
});

var express = require('express');

var bodyParser = require('body-parser');

var 앱 = express();

앱.사용(bodyParser.json());

/**

* 동기화 게이트웨이 웹훅 요청을 처리합니다.

* 요청 본문에는 문서가 포함되어 있습니다.

앱.post('/sync_request', 함수 (req, res) {

var 문서 = req.body;

콘솔.로그('문서로 웹훅 처리 :: %s', JSON.문자열화(문서));

res.sendStatus(200);

});

var 서버 = 앱.듣기(8000, 함수 () {

var 호스트 = 서버.주소().주소;

var 포트 = 서버.주소().포트;

콘솔.로그('http://%s:%s'에서 앱 듣기, 호스트, 포트);

});

다음을 실행하여 Node.js 앱 서버를 시작합니다. 노드 서버.js 를 클릭하고 REST API를 사용하여 문서를 동기화 게이트웨이에 저장하여 웹훅이 작동하는지 확인합니다:

$ curl -vX POST :4984/db/ 
        -H 'Content-Type: application/json' 
        -d '{"type": "profile", "name": "james"}'

$ curl -vX POST :4984/db/

-H '콘텐츠 유형: 애플리케이션/json'

-d '{"type": "profile", "name": "james"}'

앱 서버의 로그에 다음과 같은 출력이 표시되어야 합니다:

잘됐네요! 웹훅이 작동합니다. 다음으로 장소 API에서 동기화 게이트웨이로 JSON 데이터를 가져오는 코드를 몇 가지 추가합니다. 이를 위해 RxJS와 Request를 사용합니다. 둘 이상의 이벤트 또는 비동기 연산을 처리하는 코드는 빠르게 복잡해집니다. RxJS는 다음과 같은 계산을 수행합니다. 일등석 시민 는 읽기 및 컴파일 가능한 API를 허용하는 모델을 제공합니다. 그리고 Request 모듈은 NodeJS에서 http 요청을 그 어느 때보다 간단하게 만드는 사실상의 라이브러리입니다. 같은 디렉토리에 종속성을 설치하세요:

$ npm install request rx --save

1	$ npm 설치 요청 rx --저장

복사 requestRx.js 에서 GitHub 리포지토리 를 프로젝트 폴더에 추가합니다. 요청 API를 RxJS 구조체(flatMap, filter, subscribe...)로 래핑하기만 하면 됩니다. 예를 들어 request.get를 사용할 것입니다. requestRx.get.

라는 새 파일을 엽니다. sync.js를 사용하려면 요청Rx 그리고 Rx 모듈을 열고 다음 코드를 추가합니다:

var requestRx = require('./requestRx.js');
var Rx = require('rx');

const api_key = 'AIzaSyD4e6ZUIc9G2AxKansIUKa0enFzWZy5h8w';
const url = 'https://maps.googleapis.com/maps/api/place';
const gateway = 'http://localhost:4985/db';

var SyncRequest = {
  syncRequest: function(city) {
    console.log('city to sync with %s', city);
    // 1. Search for Places
    requestRx.get(`${url}/textsearch/json?key=${api_key}&amp;query=restaurants+in+${city}`)
      .subscribe((res) =&gt; {
        var places = JSON.parse(res.body).results;
        places = places.map(function (place) {
          place.city = city;
          place._id = place.place_id;
          delete place.place_id;
          return place;
        });
        var placesStream = Rx.Observable.fromArray(places);

        // 2. Send the Places in bulk to Sync Gateway
        requestRx({uri: `${gateway}/_bulk_docs`, method: 'POST', json: {docs: places}})
          .flatMap((docsRes) =&gt; {
            var docsStream = Rx.Observable.fromArray(docsRes.body);

            // Merge the place's photoreference with the doc id and rev
            return Rx.Observable.zip(placesStream, docsStream, (place, doc) =&gt; {
              return {
                id: doc.id,
                rev: doc.rev,
                ref: place.photos ? place.photos[0].photo_reference : 'CmRdAAAAA6MaWi5PIUhFumEYbHiM8IWHhJJvw1ss11QH1prE_x0PnUgyiyIiQmSNvfMu1lztLAA0mNdZa5Mr32ho5hE5nOKDAdOfVKcw4kLe0LKdDoYFENmRR1FE4AosTUhBvNCvEhB5HYf69MG389U27lkhrcPqGhSDbG7UhU9buWSEn2DRpy8E_R3oAg'
              }
            });
          })
          .flatMap((doc) =&gt; {

            // 3. Get the binary jpg photo using the ref property (i.e. photoreference)
            var options = {
              uri: `${url}/photo?key=${api_key}&amp;maxwidth=400&amp;photoreference=${doc.ref}`,
              encoding: null
            };
            return requestRx.get(options)
              .flatMap((photo) =&gt; {

                // 4. Save the photo as an attachment on the corresponding document
                return requestRx({
                  uri: `${gateway}/${doc.id}/photo?rev=${doc.rev}`,
                  method: 'PUT',
                  headers: {'Content-Type': 'image/jpg'},
                  body: photo.body
                })
              })
          })
          .subscribe((res) =&gt; {
          });
      });
  }
};

module.exports = SyncRequest;

var 요청Rx = require('./requestRx.js');

var Rx = require('rx');

const api_key = 'AIzaSyD4e6ZUIc9G2AxKansIUKa0enFzWZy5h8w';

const URL = 'https://maps.googleapis.com/maps/api/place';

const 게이트웨이 = 'http://localhost:4985/db';

var 동기화 요청 = {

동기화 요청: 함수(도시) {

콘솔.로그('%s와 동기화할 도시', 도시);

// 1. 장소 검색

요청Rx.get(`${URL}/텍스트 검색/json?키=${api_key}&쿼리=레스토랑+in+${도시}`)

.구독((res) => {

var 장소 = JSON.parse(res.body).결과;

장소 = 장소.지도(함수 (장소) {

장소.도시 = 도시;

장소._id = 장소.place_id;

삭제 장소.place_id;

반환 장소;

});

var 장소스트림 = Rx.관찰 가능.fromArray(장소);

// 동기화 게이트웨이로 장소를 일괄 전송합니다.

요청Rx({uri: `${게이트웨이}/_bulk_docs`, 메서드: 'POST', json: {문서: 장소}})

.플랫맵((docsRes) => {

var 문서 스트림 = Rx.관찰 가능.fromArray(docsRes.body);

// 장소의 사진 참조를 문서 ID 및 rev와 병합합니다.

반환 Rx.관찰 가능.zip(장소스트림, 문서 스트림, (장소, doc) => {

반환 {

id: doc.id,

rev: doc.rev,

ref: 장소.사진 ? 장소.사진[0].사진_참조 : 'CmRdAAAAA6MaWi5PIUhFumEYbHiM8IWHhJJvw1ss11QH1prE_x0PnUgyiyIiQmSNvfMu1lztLAA0mNdZa5Mr32ho5hE5nOKDAdOfVKcw4kLe0LKdDoYFENmRR1FE4AosTUhBvNCvEhB5HYf69MG389U27lkhrcPqGhSDbG7UhU9buWSEn2DRpy8E_R3oAg'

}

});

})

.플랫맵((doc) => {

// 3. 참조 속성(즉, 사진 참조)을 사용하여 바이너리 jpg 사진을 가져옵니다.

var 옵션 = {

uri: `${URL}/사진?키=${api_key}&최대 너비=400&사진 참조=${doc.ref}`,

인코딩: null

};

반환 요청Rx.get(옵션)

.플랫맵((사진) => {

// 4. 해당 문서에 사진을 첨부파일로 저장합니다.

반환 요청Rx({

uri: `${게이트웨이}/${doc.id}/사진?rev=${doc.rev}`,

메서드: 'PUT',

헤더: {'콘텐츠 유형': 'image/jpg'},

body: 사진.body

})

.구독((res) => {

});

}

};

모듈.수출 = 동기화 요청;

단계별 진행 상황은 다음과 같습니다:

검색어와 일치하는 장소 가져오기 런던의 레스토랑. URL에서 ES 6 문자열 보간 기능을 사용합니다.
그리고 대량문서 엔드포인트는 대용량 데이터 세트를 동기화 게이트웨이 인스턴스로 가져오는 데 매우 편리합니다. 이에 대한 자세한 내용은 문서.
문서를 저장한 후 사진을 첨부파일로 저장하려면 먼저 Places API에서 이미지를 가져와야 합니다. 그리고 인코딩 속성이 null. 문자열이 아닌 모든 응답 본문에 대해 요청 모듈에 필요합니다. 이에 대한 자세한 내용은 문서 요청.
동기화 게이트웨이에 이 첨부파일을 저장할 문서(문서 ID를 지정하여)와 해당 문서의 수정본(수정본 번호를 지정하여)을 알려야 합니다.

마지막 줄에 내보내는 마지막 줄에 동기화 요청 객체입니다. In server.js를 사용하려면 sync.js 파일을 호출하고 동기화 요청 메서드를 전달하여 도시 필드에 입력합니다:

var express = require('express');
var bodyParser = require('body-parser');
var app = express();
app.use(bodyParser.json());

var sync = require('./sync');

/**
 * Handle the Sync Gateway webhook request.
 * The request body contains the document.
 */
app.post('/sync_request', function (req, res) {
  var document = req.body;
  console.log('Handle webhook with doc :: %s', JSON.stringify(document));
  sync.syncRequest(document.city);
  res.sendStatus(200);
});

var server = app.listen(8000, function () {
  var host = server.address().address;
  var port = server.address().port;

  console.log('App listening at http://%s:%s', host, port);
});

var express = require('express');

var bodyParser = require('body-parser');

var 앱 = express();

앱.사용(bodyParser.json());

var 동기화 = require('./sync');

/**

* 동기화 게이트웨이 웹훅 요청을 처리합니다.

* 요청 본문에는 문서가 포함되어 있습니다.

앱.post('/sync_request', 함수 (req, res) {

var 문서 = req.body;

콘솔.로그('문서로 웹훅 처리 :: %s', JSON.문자열화(문서));

동기화.동기화 요청(문서.도시);

res.sendStatus(200);

});

var 서버 = 앱.듣기(8000, 함수 () {

var 호스트 = 서버.주소().주소;

var 포트 = 서버.주소().포트;

콘솔.로그('http://%s:%s'에서 앱 듣기, 호스트, 포트);

});

다음 사항을 눈치채셨을 것입니다. sync.js 는 ES6 구문으로 작성됩니다. 실행 노드 서버.js 이 작동하지 않으므로 먼저 바벨 모듈을 전 세계에 배포합니다:

npm install babel-node -g

1	npm 설치 babel-노드 -g

이제 sync.js 파일을 독립적으로 생성합니다:

babel-node -e "require('./sync.js').syncRequest('London')"

1	babel-노드 -e "require('./sync.js').syncRequest('London')"

관리 대시보드를 열어 동기화 게이트웨이에 저장된 문서를 모니터링합니다.

http://localhost:4985/_admin/

이제 각 문서가 런던의 한 장소인 20개의 문서가 표시됩니다:

Android 앱 빌드

이 섹션에서는 Android에서 Google 지도 SDK를 사용하여 사용자가 현재 위치한 도시를 가져오는 방법을 배웁니다. 이 정보를 사용하여 다음과 같은 유형의 문서를 만듭니다. 프로필 를 클릭하여 현재 도시를 저장합니다.

Android 스튜디오를 열고 새 안드로이드 스튜디오 프로젝트 시작 에서 빠른 시작 메뉴로 이동합니다.

앱 이름 지정 시티 익스플로러를 클릭하고 적절한 회사 도메인과 프로젝트 위치를 설정한 다음 다음:

대상 Android 장치 대화 상자에서 다음을 확인합니다. 휴대폰 및 태블릿를 클릭하고 최소 SDK를 API 22: Android 5.1(롤리팝) 를 클릭하고 다음:

이후 모바일에 활동 추가 대화 상자에서 추가 빈 활동 를 클릭하고 활동 이름을 지정합니다. 주요 활동:

귀하는 통합 위치 공급자 을 클릭해 디바이스의 마지막 알려진 위치를 검색합니다. In build.gradle를 클릭하고 다음 종속성을 추가합니다:

compile 'com.google.android.gms:play-services:7.5.0'

1	컴파일 'com.google.android.gms:play-services:7.5.0'

에서 위치 요청 권한을 추가합니다. AndroidManifest.xml 에서 매니페스트 XML 태그:

In MainActivity.java라는 새 메서드를 추가합니다. 빌드구글에이피클라이언트 를 호출하여 Google API SDK를 초기화하고 onCreate:

protected synchronized void buildGoogleApiClient() {
    mGoogleApiClient = new GoogleApiClient.Builder(this)
            .addConnectionCallbacks(this)
            .addOnConnectionFailedListener(this)
            .addApi(LocationServices.API)
            .build();
    mGoogleApiClient.connect();
}

보호됨 동기화 void 빌드구글에이피클라이언트() {

mGoogleApiClient = new 구글에이피클라이언트.빌더(이)

.추가 연결 콜백(이)

.추가 연결 실패 리스너(이)

.addApi(위치 서비스.API)

.빌드();

mGoogleApiClient.연결();

}

다음으로 다음을 수행합니다. 주요 활동 구현 GoogleApiClient.ConnectionCallbacks 그리고 GoogleApiClient.OnConnectionFailedListener 인터페이스에서 위치를 검색하고 온커넥티드:

@Override
public void onConnected(Bundle bundle) {
    Location mLastLocation = LocationServices.FusedLocationApi.getLastLocation(mGoogleApiClient);
    Geocoder geocoder = new Geocoder(this, Locale.getDefault());
    List

@오버라이드

public void 온커넥티드(번들 번들) {

위치 mLastLocation = 위치 서비스.FusedLocationApi.getLastLocation(mGoogleApiClient);

지오코더 지오코딩 = new 지오코더(이, 로캘.getDefault());

addresses = null; try { addresses = geocoder.getFromLocation(mLastLocation.getLatitude(), mLastLocation.getLongitude(), 1); } catch (IOException e) { e.printStackTrace(); } if (addresses.size() > 0) { String city = addresses.get(0).getLocality(); cityLabel.setText(city); } } } @Override public void onConnectionSuspended(int i) { } @Override public void onConnectionFailed(ConnectionResult connectionResult) { }

애플리케이션을 실행하면 화면 중앙에 현재 도시가 표시될 것입니다:

다음으로 프로젝트에 Couchbase Lite를 추가합니다. In build.gradle 다음을 추가합니다:

// workaround for "duplicate files during packaging of APK" issue
// see https://groups.google.com/d/msg/adt-dev/bl5Rc4Szpzg/wC8cylTWuIEJ
packagingOptions {
    exclude 'META-INF/ASL2.0'
    exclude 'META-INF/LICENSE'
    exclude 'META-INF/NOTICE'
}

// "APK 패키징 중 파일 중복" 문제 해결 방법

// https://groups.google.com/d/msg/adt-dev/bl5Rc4Szpzg/wC8cylTWuIEJ 참조

패키징 옵션 {

제외 'meta-inf/asl2.0'

제외 '메타정보/라이센스'

제외 '메타정보/공지'

}

다음에서 Couchbase Lite Android 패키지를 추가합니다. build.gradle:

compile 'com.couchbase.lite:couchbase-lite-android:1.1.0'

1	컴파일 'com.couchbase.lite:couchbase-lite-android:1.1.0'

만들기 SyncManager.java 클래스를 열고 코드를 추가하여 연속 모드에서 풀 앤 푸시 복제를 시작하세요:

public class SyncManager {
    private static final String DATABASE_NAME = "cityexplorer";
    private static final String SYNC_URL = "http://localhost:4984/db/";
    private static final String CITIES_VIEW = "getCities";

    private Context context;
    private Manager manager;
    private Database database;

    public SyncManager(Context context) {
        this.context = context;

        openDatabase();
    }

    private void openDatabase() {
        try {
            manager = new Manager(new AndroidContext(context), Manager.DEFAULT_OPTIONS);
        } catch (IOException e) {
            e.printStackTrace();
        }

        try {
            database = manager.getDatabase(DATABASE_NAME);
        } catch (CouchbaseLiteException e) {
            e.printStackTrace();
        }

        startSync();
    }

    private void startSync() {
        URL url = null;
        try {
            url = new URL(SYNC_URL);
        } catch (MalformedURLException e) {
            e.printStackTrace();
        }

        Replication push = database.createPushReplication(url);
        push.setContinuous(true);
        push.start();

        Replication pull = database.createPullReplication(url);
        pull.setContinuous(true);
        pull.start();
    }

    public Database getDatabase() {
        return database;
    }

    public void setDatabase(Database database) {
        this.database = database;
    }
}

public 클래스 SyncManager {

비공개 정적 final 문자열 데이터베이스_이름 = "cityexplorer";

비공개 정적 final 문자열 SYNC_URL = "http://localhost:4984/db/";

비공개 정적 final 문자열 CITIES_VIEW = "getCities";

비공개 컨텍스트 컨텍스트;

비공개 관리자 관리자;

비공개 데이터베이스 데이터베이스;

public SyncManager(컨텍스트 컨텍스트) {

이.컨텍스트 = 컨텍스트;

오픈 데이터베이스();

}

비공개 void 오픈 데이터베이스() {

시도 {

관리자 = new 관리자(new 안드로이드 컨텍스트(컨텍스트), 관리자.기본_옵션);

} catch (IOException e) {

e.프린트스택트레이스();

}

시도 {

데이터베이스 = 관리자.getDatabase(데이터베이스_이름);

} catch (카우치베이스 라이트 예외 e) {

e.프린트스택트레이스();

}

시작 동기화();

}

비공개 void 시작 동기화() {

URL URL = null;

시도 {

URL = new URL(SYNC_URL);

} catch (MalformedURLException e) {

e.프린트스택트레이스();

}

복제 push = 데이터베이스.createPushReplication(URL);

push.setContinuous(true);

push.시작();

복제 pull = 데이터베이스.createPullReplication(URL);

pull.setContinuous(true);

pull.시작();

}

public 데이터베이스 getDatabase() {

반환 데이터베이스;

}

public void setDatabase(데이터베이스 데이터베이스) {

이.데이터베이스 = 데이터베이스;

}

앱을 실행하고 LogCat에서 살펴보면 복제가 성공적으로 완료된 것을 확인할 수 있습니다. 하지만 지금까지 동기화된 문서를 쿼리할 수 있는 방법은 없습니다. 이를 위해 문서를 색인하는 Couchbase 보기를 사용해야 합니다. 도시 속성입니다.

In SyncManager.java에 다음 메소드를 추가합니다:

private void registerViews() {
    View citiesView = database.getView(CITIES_VIEW);
    citiesView.setMapReduce(new Mapper() {
        @Override
        public void map(Map&lt;String, Object&gt; document, Emitter emitter) {
            if (document.get("name") != null) {
                List<object width="300" height="150"> key = new ArrayList<object>();
                key.add(document.get("city"));
                emitter.emit(key, null);
            }
        }
    }, new Reducer() {
        @Override
        public Object reduce(List<object> keys, List<object> values, boolean rereduce) {
            return new Integer(values.size());
        }
    }, "7");
}

To query that view, add another method called <strong>queryCities</strong> like so:
<pre>
private void queryCities() {
    Query query = database.getView(CITIES_VIEW).createQuery();
    query.setGroupLevel(1);
    try {
        QueryEnumerator enumeration = query.run();
        for (QueryRow row : enumeration) {
            System.out.println("Row is " + row.getValue() + " and key " + row.getKey());
        }
    } catch (CouchbaseLiteException e) {
        e.printStackTrace();
    }
}

비공개 void 등록뷰() {

보기 citiesView = 데이터베이스.getView(CITIES_VIEW);

citiesView.setMapReduce(new 매퍼() {

@오버라이드

public void 지도(지도<문자열, 개체> 문서, 이미터 emitter) {

만약 (문서.get("name") != null) {

목록<객체 너비="300" 높이="150"> 키 = new ArrayList<객체>();

키.추가(문서.get("city"));

emitter.emit(키, null);

}

}, new 감속기() {

@오버라이드

public 개체 감소(목록<객체> 키, 목록<객체> 값, 부울 재환원) {

반환 new 정수(값.크기());

}

}, "7");

}

To 쿼리 그 보기, 추가 다른 메서드 호출 <강한>쿼리 도시</강한> 같은 그래서:

<pre>

비공개 void 쿼리 도시() {

쿼리 쿼리 = 데이터베이스.getView(CITIES_VIEW).createQuery();

쿼리.설정 그룹 수준(1);

시도 {

쿼리 열거자 열거형 = 쿼리.실행();

에 대한 (QueryRow 행 : 열거형) {

시스템.out.println("행은 " + 행.getValue() + " 및 키 " + 행.getKey());

}

} catch (카우치베이스 라이트 예외 e) {

e.프린트스택트레이스();

}

그리고 다음과 같이 전화하세요. 등록뷰 에서 오픈 데이터베이스 메서드를 실행하면 LogCat에서 각 도시의 장소 수를 확인할 수 있습니다:푸시 복제도 설정했지만 아직 로컬에 문서를 보존하지 않았습니다. 문서의 온커넥티드 방법의 MainActivity.java 를 사용하여 새 문서를 로컬에 유지하는 코드를 추가합니다. 유형 속성은 프로필 그리고 도시 프로퍼티를 융합된 위치 API가 반환한 도시 이름으로 설정할 수 있습니다. 앱을 실행하기 전에 이 아키텍처의 다양한 구성 요소를 요약해 보겠습니다:화살표가 색상별로 그룹화되어 있음을 알 수 있습니다:

오렌지: 사용자가 앱을 열면 프로필 문서가 로컬에 유지되고 지속적인 푸시 복제를 통해 동기화 게이트웨이로 전송되어 웹훅을 트리거합니다.
파란색: 앱 서버는 웹훅을 처리하고 특정 도시의 장소를 동기화 게이트웨이로 가져옵니다.
녹색: 해당 사용자는 동기화 기능에 정의된 액세스 규칙에 따라 문서를 받습니다.

그리고 녹색 이벤트는 항상 앱이 열린 후 얼마 후에 발생합니다. Android 앱에서 도시 쿼리를 모니터링하여 동기화 게이트웨이에서 가져온 데이터를 모니터링하는 것이 좋습니다. 이를 위해 라이브 쿼리 대신 쿼리. 업데이트 쿼리 도시 메서드를 다음과 같이 변경합니다:

private void queryCities() {
    final Query query = database.getView(CITIES_VIEW).createQuery();
    query.setGroupLevel(1);
    LiveQuery liveQuery = query.toLiveQuery();
    liveQuery.addChangeListener(new LiveQuery.ChangeListener() {
        @Override
        public void changed(LiveQuery.ChangeEvent event) {
            try {
                QueryEnumerator enumeration = query.run();
                for (QueryRow row : enumeration) {
                    Log.d("CityExplorer", "Row is " + row.getValue() + " and key " + row.getKey());
                }
            } catch (CouchbaseLiteException e) {
                e.printStackTrace();
            }
        }
    });
    liveQuery.start();
}

비공개 void 쿼리 도시() {

final 쿼리 쿼리 = 데이터베이스.getView(CITIES_VIEW).createQuery();

쿼리.설정 그룹 수준(1);

라이브 쿼리 라이브 쿼리 = 쿼리.toLiveQuery();

라이브 쿼리.추가 변경 리스너(new 라이브 쿼리.변경 리스너() {

@오버라이드

public void 변경됨(라이브 쿼리.변경 이벤트 이벤트) {

시도 {

쿼리 열거자 열거형 = 쿼리.실행();

에 대한 (QueryRow 행 : 열거형) {

로그.d("CityExplorer", "행은 " + 행.getValue() + " 및 키 " + 행.getKey());

}

} catch (카우치베이스 라이트 예외 e) {

e.프린트스택트레이스();

}

});

라이브 쿼리.시작();

}

지금까지 동기화 게이트웨이에 20개의 문서가 있어야 하며 관리자 대시보드에서 이를 확인할 수 있습니다. 애플리케이션을 다시 시작하면 프로필 문서가 생성되고 이를 Sync Gateway로 전송하여 사용자 위치 주변의 20개 장소를 가져옵니다. 이렇게 하면 동기화 게이트웨이에 20개의 새 장소가 추가됩니다:이제 동기화 게이트웨이에 41개의 문서(프로필 문서와 앱을 실행하는 디바이스의 위치에서 20개 이상의 장소)가 있고, Android 앱의 LiveQuery는 도시별로 동일한 문서를 반환합니다(이 예에서는 런던에 20개, 생테티엔 드 티네에 20개).

동기화 기능 변경하기

지금까지는 사용자를 만들지 않고 튜토리얼을 따랐습니다. 즉, 동기화 게이트웨이에 연결하는 모든 모바일 장치가 동일한 문서를 수신합니다. 이는 데이터의 크기가 커질수록 관리하기 어렵습니다. 또한 사용자가 생테티엔 드 티네에 있는 경우 런던에 있는 장소를 해당 사용자의 장치에 동기화할 필요가 없습니다. 장치별로 문서 필터링을 추가하려면 두 가지 작업을 수행합니다:

사용자를 만들고 특정 사용자로 인증합니다.
동기화 기능을 업데이트하여 특정 사용자에게 해당 도시에 있는 문서에 대한 액세스 권한을 부여하세요.

사용자를 만들려면 curl을 사용하여 관리자 포트에서 POST 요청을 보냅니다:

$ curl -vX POST :4985/db/_user/ 
        -H 'Content-Type: application/json' 
        -d '{"name": "james", "password": "letmein"}'

$ curl -vX POST :4985/db/_user/

-H '콘텐츠 유형: 애플리케이션/json'

-d '{"name": "james", "password": "letmein"}'

Android 앱에서 시작 동기화 메서드의 SyncManager.java 기본 인증자가 동일한 자격 증명을 전달합니다:

private void startSync() {
    URL url = null;
    try {
        url = new URL(SYNC_URL);
    } catch (MalformedURLException e) {
        e.printStackTrace();
    }
    Authenticator authenticator = new BasicAuthenticator("james", "letmein");
    
    Replication push = database.createPushReplication(url);
    push.setContinuous(true);
    push.setAuthenticator(authenticator);
    push.start();
    
    Replication pull = database.createPullReplication(url);
    pull.setContinuous(true);
    pull.setAuthenticator(authenticator);
    pull.start();
}

비공개 void 시작 동기화() {

URL URL = null;

시도 {

URL = new URL(SYNC_URL);

} catch (MalformedURLException e) {

e.프린트스택트레이스();

}

인증자 인증자 = new 기본 인증자("james", "letmein");

복제 push = 데이터베이스.createPushReplication(URL);

push.setContinuous(true);

push.setAuthenticator(인증자);

push.시작();

복제 pull = 데이터베이스.createPullReplication(URL);

pull.setContinuous(true);

pull.setAuthenticator(인증자);

pull.시작();

}

로 이동하여 동기화 탭(http://localhost:4985/_admin/db/db/syncUpdate)에서 동기화 기능을 다음과 같이 설정합니다:

function(doc, oldDoc) {
        if (doc.type == "profile") {
          channel(doc.city);
          access(doc._id, doc.city);
        } else if (doc.type == "city") {
            channel(doc.city);
        }
      }

함수(doc, oldDoc) {

만약 (doc.유형 == "프로필") {

채널(doc.도시);

액세스(doc._id, doc.도시);

} else 만약 (doc.유형 == "city") {

채널(doc.도시);

}

그런 다음 라이브 미리보기 모드 버튼을 누르면 상단 배너가 노란색으로 바뀝니다.즉, 무작위 문서에서 동기화 기능을 테스트할 수 있지만 아직 배포된 것은 없으며 결과를 테스트하는 용도로만 사용할 수 있습니다. 무작위 버튼을 사용하면 임의의 문서가 입력으로 주어졌을 때 채널/액세스 출력을 확인할 수 있습니다:이 새로운 동기화 기능을 실제로 배포하려면 동기화 게이트웨이를 중지하고 구성 파일을 업데이트한 다음 다시 시작하는 것이 가장 좋으며, 동기화 게이트웨이를 다시 시작한 후에는 장치에서 앱을 제거하고 다시 실행하세요. 동일한 40개의 문서가 복제되는 것을 확인할 수 있을 것입니다. 실제로 동기화 기능을 업데이트했지만 지금까지 유지된 문서가 새 동기화 기능을 통해 실행될 기회를 얻지 못한 것입니다. 이 문제를 해결하려면 재동기화 작업에 대한 자세한 내용은 다음 섹션을 참조하세요.

재동기화

동기화 기능을 수정할 때마다 반드시 _resync 엔드포인트를 사용하여 데이터베이스의 모든 기존 문서에 대한 채널 액세스 규칙을 다시 계산합니다:

$ curl -vX POST http://localhost:4985/db/_resync

1	$ curl -vX POST http://localhost:4985/db/_resync

앱을 삭제하고 다시 시작합니다. 이번에는 사용자가 다음 위치에 있기 때문에 LogCat에 20개 장소만 표시됩니다. 생테티엔 드 티네 에 액세스할 수 없으며 해당 사용자는 런던 채널로 이동하므로 해당 문서를 가져오지 않습니다.

결론

이 튜토리얼에서는 웹훅을 사용하여 앱 서버를 사용하여 타사 API에서 동기화 게이트웨이로 문서를 가져오는 방법을 배웠습니다. 또한 재동기화 엔드포인트에 동기화 기능을 변경하여 채널에 대한 액세스를 업데이트합니다.

제임스 노센티니, 모바일 테크니컬 라이터, Couchbase

이 문서 공유하기

Platform

Self-Managed

Services

Capabilities

Why Couchbase?

Migrate to Capella

By Use Case

By Industry

By Application Need

Popular Docs

By Developer Role

Quickstart

Resource Center

About

Partnerships

Our Services

Partners: Register a Deal

Ready to register a deal with Couchbase?

Marriott

카우치베이스 모바일: 동기화 기능에서 읽기 액세스 권한을 변경하고 변경 사항을 Android 앱에 복제하기

시작하기

동기화 게이트웨이 웹훅

앱 서버

Android 앱 빌드

동기화 기능 변경하기

재동기화

결론

받은 편지함에서 카우치베이스 블로그 업데이트 받기

작성자

게시자 제임스 노센티니, 모바일 테크니컬 라이터, Couchbase

댓글 남기기 응답 취소

카우치베이스 카펠라를 시작할 준비가 되셨나요?

구축 시작

카펠라 무료 사용

연락하기