การลงชื่อสมัครใช้แบบด่วนและยืนยันแล้ว

ภาพรวม

เว็บ iOS API

Google Maps Platform พร้อมใช้งานสำหรับเว็บ (JS, TS), Android และ iOS รวมถึงมี API บริการเว็บสำหรับการรับข้อมูลเกี่ยวกับสถานที่ เส้นทาง และระยะทาง ตัวอย่างในคู่มือนี้เขียนขึ้นสำหรับแพลตฟอร์มเดียว แต่มีลิงก์เอกสารประกอบสำหรับการติดตั้งใช้งานในแพลตฟอร์มอื่นๆ

สร้างเลย

Quick Builder ในคอนโซล Google Cloud ช่วยให้คุณสร้างการเติมข้อความอัตโนมัติในแบบฟอร์มที่อยู่ได้โดยใช้ UI แบบอินเทอร์แอกทีฟที่สร้างโค้ด JavaScript ให้คุณ

ผู้ใช้เริ่มคุ้นเคยกับการใช้ชีวิตและการทำงานในโลกดิจิทัลที่ความสะดวก ความรวดเร็ว และความปลอดภัยเป็นความคาดหวังพื้นฐาน เมื่อสมัครใช้บริการต่างๆ เช่น บัตรเครดิต บัญชีธนาคาร หรือสินเชื่อ ลูกค้าคาดหวังว่ากระบวนการจะรวดเร็วและง่ายดาย

ยิ่งผู้ใช้ต้องพิมพ์หรือป้อนข้อมูลซ้ำๆ มากเท่าใด โอกาสที่คุณจะรักษาผู้ใช้ไว้เป็นลูกค้าก็ยิ่งน้อยลงเท่านั้น การสร้างประสบการณ์การลงชื่อสมัครใช้ที่รวดเร็ว ง่ายดาย และได้รับการยืนยันจะช่วยปรับปรุงประสบการณ์ของผู้ใช้ไปพร้อมกับช่วยให้คุณได้เปรียบในการรักษาผู้ใช้ไว้ในเว็บไซต์

ที่อยู่ที่ป้อนด้วยตนเองอาจทำให้ Conversion ลดลง ข้อมูล CRM ผิดพลาด และข้อผิดพลาดในการนำส่งที่มีค่าใช้จ่ายสูง ฟีเจอร์ Quick & Verified Sign-up ช่วยให้การลงชื่อสมัครใช้รวดเร็วขึ้น โดยจะแนะนำที่อยู่ใกล้เคียงทันทีด้วยการแตะเพียงไม่กี่ครั้ง และแสดงที่อยู่ที่ป้อนเพื่อยืนยันด้วยภาพ ซึ่งช่วยให้ผู้ใช้มั่นใจว่าได้ป้อนที่อยู่ที่ถูกต้อง การยืนยันที่อยู่ของผู้ใช้โดยใช้ตำแหน่งปัจจุบันยังช่วยป้องกันการประพฤติมิชอบและเพิ่มความมั่นใจของผู้ใช้ในผลิตภัณฑ์และบริการของคุณด้วย นอกจากนี้ การยืนยันยังช่วยเพิ่มความมั่นใจในการให้บริการบัตรเครดิตและบัตรธนาคารเสมือนจริงได้ทันที

เอกสารนี้ให้คำแนะนำในการติดตั้งใช้งานเพื่อสร้างประสบการณ์การลงชื่อสมัครใช้แบบด่วนและยืนยันแล้วด้วย Google Maps Platform เนื่องจากผู้ใช้มีแนวโน้มที่จะลงชื่อสมัครใช้บนอุปกรณ์เคลื่อนที่มากที่สุด ตัวอย่างการติดตั้งใช้งานส่วนใหญ่ในเอกสารนี้จึงมุ่งเน้นที่ Android ดูตัวอย่างที่สมบูรณ์ได้ที่ซอร์สโค้ดตัวอย่าง นอกจากนี้ คุณยังใช้ iOS SDK เพื่อบรรลุเป้าหมายเดียวกันได้ด้วย

แผนภาพต่อไปนี้แสดง API หลักที่เกี่ยวข้องกับการสร้างโซลูชัน (คลิกเพื่อขยาย)

กำลังเปิดใช้ API

หากต้องการใช้คำแนะนำเหล่านี้ คุณต้องเปิดใช้ API ต่อไปนี้ในคอนโซล Google Cloud

ดูข้อมูลเพิ่มเติมเกี่ยวกับการตั้งค่าได้ที่การเริ่มต้นใช้งาน Google Maps Platform

ส่วนแนวทางปฏิบัติแนะนำ

เอกสารนี้ครอบคลุมแนวทางปฏิบัติและการปรับแต่งต่อไปนี้

  • ไอคอนเครื่องหมายถูกคือแนวทางปฏิบัติแนะนำหลัก
  • ไอคอนรูปดาวเป็นการปรับแต่งที่ไม่บังคับ แต่เราขอแนะนำให้ใช้เพื่อปรับปรุงโซลูชัน
การเพิ่มการเติมข้อความอัตโนมัติลงในช่องป้อนข้อมูล ป้อนข้อมูลแบบฟอร์มที่อยู่โดยอัตโนมัติ เพิ่มฟังก์ชันการทำงานแบบพิมพ์ไปเรื่อยๆ เพื่อปรับปรุงประสบการณ์ของผู้ใช้ในทุกแพลตฟอร์มและปรับปรุงความถูกต้องของที่อยู่โดยใช้การกดแป้นพิมพ์น้อยที่สุด
การให้ภาพยืนยันที่อยู่ ให้ผู้ใช้เห็นที่อยู่ของตนบนแผนที่เพื่อเป็นการยืนยันด้วยภาพว่าได้ป้อนที่อยู่ที่ถูกต้อง
การเปรียบเทียบที่อยู่ที่ผู้ใช้ป้อนกับตำแหน่งของอุปกรณ์ เปรียบเทียบที่อยู่ที่ผู้ใช้เลือกหรือป้อนกับตำแหน่งปัจจุบันของอุปกรณ์เพื่อช่วยระบุว่าผู้ใช้อยู่ที่ที่อยู่ที่ระบุ (ผู้ใช้ควรอยู่ที่บ้านเมื่อลงชื่อสมัครใช้เพื่อให้ฟีเจอร์นี้ทำงานได้)
เคล็ดลับในการปรับปรุงการลงชื่อสมัครใช้ที่รวดเร็วและได้รับการยืนยันเพิ่มเติม คุณสามารถปรับปรุงการป้อนที่อยู่ให้ดียิ่งขึ้นด้วยการเพิ่มสิ่งต่างๆ เช่น การปรับแต่งรูปลักษณ์ของวิดเจ็ตเติมข้อความอัตโนมัติ หรือให้ผู้ใช้เลือกชื่อธุรกิจหรือจุดสังเกตเป็นที่อยู่

การเพิ่มการเติมข้อความอัตโนมัติลงในช่องป้อนข้อมูล

ตัวอย่างนี้ใช้ Places SDK สำหรับ Android พร้อมใช้งานในภาษาต่อไปนี้ด้วย iOS | JavaScript

Place Autocomplete ช่วยให้การป้อนที่อยู่ในแอปพลิเคชันง่ายขึ้น ซึ่งจะนำไปสู่อัตรา Conversion ที่สูงขึ้นและประสบการณ์ที่ราบรื่นสำหรับลูกค้า การเติมข้อความอัตโนมัติจะแสดงช่องป้อนข้อมูลด่วนช่องเดียวพร้อมการคาดคะเนที่อยู่แบบ "พิมพ์ล่วงหน้า" ซึ่งใช้เพื่อป้อนข้อมูลในแบบฟอร์มที่อยู่สำหรับการลงชื่อสมัครใช้โดยอัตโนมัติได้ การรวม Place Autocomplete ไว้ในขั้นตอนการลงชื่อสมัครใช้จะช่วยให้คุณทำสิ่งต่อไปนี้ได้

  • ลดข้อผิดพลาดในการป้อนที่อยู่
  • ลดจำนวนขั้นตอนในกระบวนการลงชื่อสมัครใช้
  • ลดความซับซ้อนของประสบการณ์การป้อนที่อยู่ในอุปกรณ์เคลื่อนที่หรืออุปกรณ์ที่สวมใส่ได้
  • ลดการกดแป้นพิมพ์และเวลาทั้งหมดที่ลูกค้าต้องใช้ในการลงชื่อสมัครใช้อย่างมาก

เมื่อผู้ใช้เลือกช่องป้อนข้อมูลการเติมข้อความอัตโนมัติและเริ่มพิมพ์ รายการการคาดคะเนที่อยู่จะปรากฏขึ้น

เมื่อผู้ใช้เลือกที่อยู่จากรายการการคาดคะเน คุณสามารถใช้การตอบกลับเพื่อยืนยันที่อยู่และรับตำแหน่งได้ จากนั้นแอปพลิเคชันจะป้อนข้อมูลในช่องที่ถูกต้องของแบบฟอร์มป้อนที่อยู่ได้ ดังที่แสดงในรูปภาพต่อไปนี้

วิดีโอ: ปรับปรุงแบบฟอร์มที่อยู่ด้วย Place Autocomplete

แบบฟอร์มที่อยู่

Android

iOS

เว็บ

Google Maps Platform มีวิดเจ็ต Place Autocomplete สำหรับแพลตฟอร์มบนอุปกรณ์เคลื่อนที่และเว็บ วิดเจ็ตที่แสดงในรูปภาพก่อนหน้าจะมีกล่องโต้ตอบการค้นหาพร้อมฟังก์ชันการเติมข้อความอัตโนมัติในตัว ซึ่งคุณสามารถเพิ่มประสิทธิภาพสำหรับการค้นหาที่กำหนดขอบเขตตามสถานที่ได้ด้วย

ส่วนนี้จะอธิบายวิธีใช้การเติมที่อยู่อัตโนมัติสําหรับการลงชื่อสมัครใช้ที่รวดเร็วและได้รับการยืนยัน

การเพิ่มวิดเจ็ต Place Autocomplete

ใน Android คุณสามารถเพิ่มวิดเจ็ตการเติมข้อความอัตโนมัติได้โดยใช้ Intent การเติมข้อความอัตโนมัติที่เปิดใช้ Place Autocomplete จากช่องป้อนข้อมูลบรรทัดที่อยู่ 1 ซึ่งผู้ใช้จะเริ่มป้อนที่อยู่ เมื่อเริ่มพิมพ์ ผู้ใช้จะเลือกที่อยู่จากรายการการคาดคะเนการเติมข้อความอัตโนมัติได้

ก่อนอื่น ให้เตรียมตัวเปิดกิจกรรมโดยใช้ ActivityResultLauncher ซึ่งจะรอฟังผลลัพธ์จากกิจกรรมที่เปิดขึ้น Callback ผลลัพธ์จะมีออบเจ็กต์ Place ที่สอดคล้องกับที่อยู่ที่ผู้ใช้เลือกจากการคาดคะเนการเติมข้อความอัตโนมัติ

    private final ActivityResultLauncher<Intent> startAutocomplete =
            registerForActivityResult(
                    new ActivityResultContracts.StartActivityForResult(),
                    result -> {
                        if (result.getResultCode() == Activity.RESULT_OK) {
                            Intent intent = result.getData();
                            if (intent != null) {
                                AutocompletePrediction prediction =
                                        PlaceAutocomplete.getPredictionFromIntent(intent);
                                AutocompleteSessionToken sessionToken =
                                        PlaceAutocomplete.getSessionTokenFromIntent(intent);
                                if (prediction != null) {
                                    List<Place.Field> fields =
                                            Arrays.asList(
                                                    Place.Field.ADDRESS_COMPONENTS,
                                                    Place.Field.LOCATION,
                                                    Place.Field.VIEWPORT);
                                    FetchPlaceRequest request =
                                            FetchPlaceRequest.builder(
                                                            prediction.getPlaceId(), fields)
                                                    .setSessionToken(sessionToken)
                                                    .build();
                                    placesClient
                                            .fetchPlace(request)
                                            .addOnSuccessListener(
                                                    response -> {
                                                        Place place = response.getPlace();
                                                        // Write a method to read the address
                                                        // components from the Place
                                                        // and populate the form with the address
                                                        // components
                                                        Log.d(
                                                                TAG,
                                                                "Place: "
                                                                        + place
                                                                                .getAddressComponents());
                                                        fillInAddress(place);
                                                    })
                                            .addOnFailureListener(
                                                    exception -> {
                                                        Log.e(
                                                                TAG,
                                                                "Place not found: "
                                                                        + exception.getMessage());
                                                    });
                                }
                            }
                        } else if (result.getResultCode() == Activity.RESULT_CANCELED) {
                            // The user canceled the operation.
                            Log.i(TAG, "User canceled autocomplete");
                        }
                    });

จากนั้นกำหนดพร็อพเพอร์ตี้ช่อง สถานที่ และประเภทของ Intent Place Autocomplete แล้วสร้างด้วย Autocomplete.IntentBuilder สุดท้าย ให้เปิดใช้งาน Intent โดยใช้ ActivityResultLauncher ที่กำหนดไว้ในตัวอย่างโค้ดก่อนหน้า

    private void startAutocompleteIntent() {
        // Build the autocomplete intent with country and type filters applied
        Intent intent =
                new PlaceAutocomplete.IntentBuilder()
                        .setCountries(List.of("US"))
                        .setTypesFilter(List.of(PlaceTypes.ADDRESS))
                        .build(this);
        startAutocomplete.launch(intent);
    }

การจัดการที่อยู่ที่แสดงโดย Place Autocomplete

การกำหนด ActivityResultLauncher ก่อนหน้านี้ยังกำหนดสิ่งที่ควรทำเมื่อผลลัพธ์ของกิจกรรมแสดงใน Callback ด้วย หากผู้ใช้เลือกการคาดคะเน ระบบจะส่งการคาดคะเนนั้นใน Intent ที่มีอยู่ในออบเจ็กต์ผลลัพธ์ เนื่องจาก Intent สร้างขึ้นโดย Autocomplete.IntentBuilder เมธอด Autocomplete.getPlaceFromIntent() จึงสามารถดึงออบเจ็กต์ Place จาก Intent ได้

    private final ActivityResultLauncher<Intent> startAutocomplete =
            registerForActivityResult(
                    new ActivityResultContracts.StartActivityForResult(),
                    result -> {
                        if (result.getResultCode() == Activity.RESULT_OK) {
                            Intent intent = result.getData();
                            if (intent != null) {
                                AutocompletePrediction prediction =
                                        PlaceAutocomplete.getPredictionFromIntent(intent);
                                AutocompleteSessionToken sessionToken =
                                        PlaceAutocomplete.getSessionTokenFromIntent(intent);
                                if (prediction != null) {
                                    List<Place.Field> fields =
                                            Arrays.asList(
                                                    Place.Field.ADDRESS_COMPONENTS,
                                                    Place.Field.LOCATION,
                                                    Place.Field.VIEWPORT);
                                    FetchPlaceRequest request =
                                            FetchPlaceRequest.builder(
                                                            prediction.getPlaceId(), fields)
                                                    .setSessionToken(sessionToken)
                                                    .build();
                                    placesClient
                                            .fetchPlace(request)
                                            .addOnSuccessListener(
                                                    response -> {
                                                        Place place = response.getPlace();
                                                        // Write a method to read the address
                                                        // components from the Place
                                                        // and populate the form with the address
                                                        // components
                                                        Log.d(
                                                                TAG,
                                                                "Place: "
                                                                        + place
                                                                                .getAddressComponents());
                                                        fillInAddress(place);
                                                    })
                                            .addOnFailureListener(
                                                    exception -> {
                                                        Log.e(
                                                                TAG,
                                                                "Place not found: "
                                                                        + exception.getMessage());
                                                    });
                                }
                            }
                        } else if (result.getResultCode() == Activity.RESULT_CANCELED) {
                            // The user canceled the operation.
                            Log.i(TAG, "User canceled autocomplete");
                        }
                    });

จากนั้นเรียกใช้ Place.getAddressComponents() และจับคู่คอมโพเนนต์ที่อยู่แต่ละรายการกับช่องป้อนข้อมูลที่เกี่ยวข้องในแบบฟอร์มที่อยู่ โดยป้อนค่าจากสถานที่ที่ผู้ใช้เลือกในช่อง

การบันทึกข้อมูลที่อยู่จากการคาดคะเนแทนที่อยู่ซึ่งป้อนด้วยตนเองจะช่วยให้มั่นใจได้ว่าที่อยู่ถูกต้อง เป็นที่รู้จัก และสามารถจัดส่งได้ รวมถึงช่วยลดการกดแป้นพิมพ์ของผู้ใช้

ข้อควรพิจารณาเมื่อใช้ Place Autocomplete

Place Autocomplete มีตัวเลือกมากมายที่ช่วยให้มีความยืดหยุ่นในการใช้งานหากคุณต้องการใช้มากกว่าแค่วิดเจ็ต คุณสามารถใช้บริการต่างๆ ร่วมกันเพื่อให้ได้สิ่งที่ต้องการในการจับคู่สถานที่ตั้งอย่างถูกต้อง

  • สำหรับแบบฟอร์ม ADDRESS ให้ตั้งค่าพารามิเตอร์ types เป็น address เพื่อจำกัดการจับคู่ให้เป็นที่อยู่แบบเต็ม ดูข้อมูลเพิ่มเติมเกี่ยวกับประเภทที่รองรับในคำขอ Place Autocomplete

  • ตั้งค่าข้อจำกัดและอคติที่เหมาะสมหากไม่ต้องการค้นหาทั่วโลก มีพารามิเตอร์จำนวนหนึ่งที่สามารถใช้เพื่อให้น้ำหนักหรือจำกัดการจับคู่เฉพาะภูมิภาคที่เจาะจงเท่านั้น

    • ใช้ RectangularBounds เพื่อกำหนดขอบเขตสี่เหลี่ยมผืนผ้าเพื่อจำกัดพื้นที่ และใช้ setLocationRestriction() เพื่อให้แน่ใจว่าระบบจะแสดงผลเฉพาะที่อยู่ในพื้นที่เหล่านั้น

    • ใช้ setCountries() เพื่อจำกัดการตอบกลับเฉพาะบางประเทศ

  • ปล่อยให้ช่องต่างๆ แก้ไขได้ในกรณีที่ช่องบางช่องไม่ตรงกัน และอนุญาตให้ลูกค้าอัปเดตที่อยู่ได้หากจำเป็น เนื่องจากที่อยู่ส่วนใหญ่ที่ Place Autocomplete แสดงผลไม่มีหมายเลขสถานที่ย่อย เช่น หมายเลขอพาร์ตเมนต์ ห้องชุด หรือยูนิต คุณจึงสามารถย้ายโฟกัสไปยังบรรทัดที่อยู่ 2 เพื่อกระตุ้นให้ผู้ใช้กรอกข้อมูลดังกล่าวหากจำเป็น

การแสดงภาพยืนยันที่อยู่

ตัวอย่างนี้ใช้ Maps SDK สำหรับ Android พร้อมใช้งานในภาษาต่อไปนี้ด้วย iOS | JavaScript

ในการป้อนที่อยู่ ให้แสดงการยืนยันที่อยู่บนแผนที่ให้ผู้ใช้เห็น ซึ่งช่วยให้ผู้ใช้มั่นใจได้มากขึ้นว่าที่อยู่ถูกต้อง

รูปภาพต่อไปนี้แสดงแผนที่ใต้ที่อยู่พร้อมหมุดที่ปักไว้ตามที่อยู่ที่ป้อน

ตัวอย่างต่อไปนี้เป็นไปตามขั้นตอนพื้นฐานในการเพิ่มแผนที่ใน Android โปรดดูรายละเอียดเพิ่มเติมในเอกสารประกอบ

กำลังเพิ่มSupportMapFragment

ก่อนอื่น ให้เพิ่มส่วนย่อย SupportMapFragment ลงในไฟล์ XML ของเลย์เอาต์

    <fragment
        android:name="com.google.android.gms.maps.SupportMapFragment"
        android:id="@+id/confirmation_map"
        android:layout_width="match_parent"
        android:layout_height="match_parent"/>

จากนั้นเพิ่ม Fragment โดยใช้โปรแกรมหากยังไม่มี

    private void showMap(Place place) {
        coordinates = place.getLocation();

        // It isn't possible to set a fragment's id programmatically so we set a tag instead and
        // search for it using that.
        mapFragment =
                (SupportMapFragment)
                        getSupportFragmentManager().findFragmentByTag(MAP_FRAGMENT_TAG);

        // We only create a fragment if it doesn't already exist.
        if (mapFragment == null) {
            mapPanel = ((ViewStub) findViewById(R.id.stub_map)).inflate();
            GoogleMapOptions mapOptions = new GoogleMapOptions();
            mapOptions.mapToolbarEnabled(false);

            // To programmatically add the map, we first create a SupportMapFragment.
            mapFragment = SupportMapFragment.newInstance(mapOptions);

            // Then we add it using a FragmentTransaction.
            getSupportFragmentManager()
                    .beginTransaction()
                    .add(R.id.confirmation_map, mapFragment, MAP_FRAGMENT_TAG)
                    .commit();
            mapFragment.getMapAsync(this);
        } else {
            updateMap(coordinates);
        }
    }

การรับแฮนเดิลไปยัง Fragment และการลงทะเบียน Callback

  1. หากต้องการรับแฮนเดิลไปยัง Fragment ให้เรียกใช้เมธอด FragmentManager.findFragmentById และส่งรหัสทรัพยากรของ Fragment ในไฟล์เลย์เอาต์ หากคุณเพิ่ม Fragment แบบไดนามิก ให้ข้ามขั้นตอนนี้เนื่องจากคุณได้แฮนเดิลแล้ว

  2. เรียกใช้เมธอด getMapAsync เพื่อตั้งค่า Callback ใน Fragment

ตัวอย่างเช่น หากคุณเพิ่ม Fragment แบบคงที่ ให้ทำดังนี้

Kotlin

val mapFragment = supportFragmentManager
    .findFragmentById(R.id.map) as SupportMapFragment
mapFragment.getMapAsync(this)

      

Java

SupportMapFragment mapFragment =
        (SupportMapFragment) getSupportFragmentManager().findFragmentById(R.id.map);
mapFragment.getMapAsync(this);

      

การจัดสไตล์และเพิ่มเครื่องหมายลงในแผนที่

เมื่อแผนที่พร้อมแล้ว ให้กำหนดรูปแบบ จัดกล้องให้อยู่ตรงกลาง และเพิ่มเครื่องหมายที่พิกัดของที่อยู่ที่ป้อน โค้ดต่อไปนี้ใช้การจัดรูปแบบที่กำหนดไว้ในออบเจ็กต์ JSON หรือคุณจะโหลดรหัสแผนที่ที่กำหนดไว้ด้วยการจัดรูปแบบแผนที่ในระบบคลาวด์ก็ได้

    @Override
    public void onMapReady(@NonNull GoogleMap googleMap) {
        map = googleMap;
        try {
            // Customise the styling of the base map using a JSON object defined
            // in a string resource.
            boolean success =
                    map.setMapStyle(MapStyleOptions.loadRawResourceStyle(this, R.raw.style_json));

            if (!success) {
                Log.e(TAG, "Style parsing failed.");
            }
        } catch (Resources.NotFoundException e) {
            Log.e(TAG, "Can't find style. Error: ", e);
        }
        map.moveCamera(CameraUpdateFactory.newLatLngZoom(coordinates, 15f));
        marker = map.addMarker(new MarkerOptions().position(coordinates));
    }

(ดูตัวอย่างโค้ดแบบเต็ม)

การปิดใช้การควบคุมแผนที่

หากต้องการให้แผนที่ดูสะอาดตาโดยแสดงตำแหน่งโดยไม่มีการควบคุมแผนที่เพิ่มเติม เช่น เข็มทิศหรือแถบเครื่องมือ ให้ลองปิดใช้การควบคุมที่ไม่จำเป็น ใน Android อีกตัวเลือกหนึ่งคือการเปิดใช้โหมด Lite เพื่อให้มีการโต้ตอบแบบจำกัด

การเปรียบเทียบที่อยู่ที่ผู้ใช้ป้อนกับตำแหน่งของอุปกรณ์

การขอหลักฐานแสดงที่อยู่เพื่อให้มั่นใจว่าผู้ใช้อยู่ในที่อยู่ที่ป้อนอาจมีความซับซ้อนเนื่องจากปัจจัยต่างๆ เช่น สถานที่ตั้งของผู้ใช้อยู่ห่างไกล ผู้ใช้ย้ายไปยังที่อยู่ใหม่ หรือธุรกิจดิจิทัล (เช่น ธนาคารดิจิทัล) ที่ไม่มีสถานที่ตั้งจริงซึ่งผู้ใช้สามารถไปเพื่อแสดงหลักฐานแสดงที่อยู่ด้วยใบเรียกเก็บเงินค่าสาธารณูปโภคหรือเอกสารอื่นๆ การระบุวิธีทางดิจิทัลในการยืนยันที่อยู่ของผู้ใช้ช่วยให้คุณมอบประสบการณ์การลงชื่อสมัครใช้ที่รวดเร็วและราบรื่นยิ่งขึ้นได้

ความปลอดภัยเป็นสิ่งสำคัญที่สุดในการตรวจสอบที่อยู่ โดยเฉพาะอย่างยิ่งเมื่อใช้กระบวนการลงชื่อสมัครใช้แบบดิจิทัล ส่วนนี้จะให้คำแนะนำและตัวอย่างสำหรับการตรวจสอบว่าตำแหน่งของผู้ใช้ในระหว่างการลงชื่อสมัครใช้ตรงกับที่อยู่ที่ผู้ใช้ป้อนเป็นที่อยู่ของตนเองหรือไม่

กระบวนการเปรียบเทียบที่อยู่ที่ป้อนกับตำแหน่งของอุปกรณ์ประกอบด้วยขั้นตอนต่อไปนี้

  1. การแปลงที่อยู่ที่ผู้ใช้ป้อนเป็นพิกัดทางภูมิศาสตร์
  2. การแจ้งขอสิทธิ์จากผู้ใช้เพื่อรับตำแหน่งของอุปกรณ์
  3. การคำนวณระยะทางระหว่างที่อยู่ที่ป้อนกับตำแหน่งของอุปกรณ์ คุณสามารถกำหนดระยะทางสูงสุดที่นับว่าเป็นการจับคู่ที่อยู่กับสถานที่ตั้ง

รูปภาพต่อไปนี้เป็นตัวอย่างวิธีที่คุณอาจแจ้งให้ผู้ใช้เปรียบเทียบที่อยู่ที่ป้อนกับตำแหน่งปัจจุบัน

การแปลงที่อยู่ที่ผู้ใช้ป้อนเป็นพิกัดทางภูมิศาสตร์

ตัวอย่างนี้ใช้ Places SDK สำหรับ Android พร้อมใช้งานในภาษาต่อไปนี้ด้วย iOS | JavaScript | Geocoding API

หลังจากผู้ใช้ยอมรับการยืนยันที่อยู่ (โดยแตะ "ยืนยันว่าฉันอยู่ที่นั่นตอนนี้" ในภาพก่อนหน้า) ขั้นตอนแรกในการเปรียบเทียบที่อยู่กับตำแหน่งปัจจุบันคือการแปลงที่อยู่ที่ป้อนเป็นพิกัดทางภูมิศาสตร์

หากผู้ใช้เลือกที่อยู่ด้วย Place Autocomplete อย่าลืมขอ Place.Field.LAT_LNG ในรายการช่อง Place Autocomplete ดังที่แสดงในข้อมูลโค้ดการเพิ่มวิดเจ็ต Place Autocomplete และเรียกใช้เมธอด Place.getLatLng() เพื่อรับพิกัดทางภูมิศาสตร์ของที่อยู่ที่เลือก

coordinates = place.getLatLng();

หากผู้ใช้ป้อนที่อยู่ด้วยตนเองหรือแก้ไขหลังจากที่ Place Autocomplete กรอกข้อมูลในช่องแล้ว ให้ใช้บริการ Android Geocoder หรือ Geocoding API เพื่อค้นหาพิกัดที่สอดคล้องกับที่อยู่นั้น

ตัวอย่าง

https://maps.googleapis.com/maps/api/geocode/json?address=1600%20Amphitheatre%2BParkway%2C%20Mountain%20View%2C%20CA%2094043&key=YOUR_API_KEY

อย่าลืมเข้ารหัส URL การเรียก Geocoding API

ข้อมูลอ้างอิงด่วนสำหรับการเข้ารหัส URL: %20 = เว้นวรรค, %2B = + (บวก), %2C = , (คอมมา)

แจ้งให้ผู้ใช้ขอสิทธิ์เพื่อรับตำแหน่งของอุปกรณ์

หากต้องการดูตำแหน่งอุปกรณ์ของผู้ใช้ คุณต้องขอการให้สิทธิ์จากผู้ใช้เพื่อเปิดใช้บริการตำแหน่ง ใช้คำแนะนำในเอกสารประกอบของ Android เกี่ยวกับการสร้างแอปที่รับรู้ถึงตำแหน่งเพื่อใช้ขั้นตอนต่อไปนี้

  • ขอสิทธิ์เข้าถึงตำแหน่งแบบให้สิทธิ์ครั้งเดียวในระดับที่แน่นอน (ACCESS_FINE_LOCATION)

  • หากผู้ใช้ให้สิทธิ์เข้าถึงตำแหน่ง ให้รับตำแหน่งของผู้ใช้

  • หากผู้ใช้ปฏิเสธการเข้าถึงตำแหน่ง ให้จัดการการปฏิเสธอย่างเหมาะสม ตัวอย่างเช่น คุณอาจแสดงข้อความประเภทต่อไปนี้ (สมมติว่าคุณไม่ได้จัดเก็บตำแหน่งปัจจุบันของผู้ใช้)

    "หากคุณไม่อนุญาตให้แอปทราบตำแหน่งที่แน่นอน คุณจะต้องยืนยันทางไปรษณีย์เพื่อเปิดใช้งานบัญชี [ตกลง]"

รูปภาพต่อไปนี้แสดงตัวอย่างข้อความแจ้งให้ผู้ใช้อนุญาตสิทธิ์ในการรับตำแหน่งของอุปกรณ์

หากต้องการตรวจสอบสิทธิ์เข้าถึงตำแหน่ง ให้เตรียมตัวเปิดกิจกรรมที่จะฟังผลลัพธ์จากกิจกรรมที่เปิดด้วย ActivityResultLauncher Callback ผลลัพธ์จะมีสตริงที่ระบุว่าผู้ใช้ให้หรือปฏิเสธสิทธิ์ที่ขอ

    // Register the permissions callback, which handles the user's response to the
    // system permissions dialog. Save the return value, an instance of
    // ActivityResultLauncher, as an instance variable.
    private final ActivityResultLauncher<String> requestPermissionLauncher =
            registerForActivityResult(
                    new ActivityResultContracts.RequestPermission(),
                    isGranted -> {
                        if (isGranted) {
                            // Since ACCESS_FINE_LOCATION is the only permission in this sample,
                            // run the location comparison task once permission is granted.
                            // Otherwise, check which permission is granted.
                            getAndCompareLocations();
                        } else {
                            // Fallback behavior if user denies permission
                            Log.d(TAG, "User denied permission");
                        }
                    });

จากนั้นตรวจสอบว่าแอปมีสิทธิ์เข้าถึงACCESS_FINE_LOCATIONอยู่แล้วหรือไม่ หากไม่มี ให้ขอสิทธิ์จากผู้ใช้โดยเปิดกิจกรรมคำขอสิทธิ์โดยใช้ Launcher ที่กำหนดไว้ในขั้นตอนก่อนหน้า

    private void checkLocationPermissions() {
        if (ContextCompat.checkSelfPermission(this, ACCESS_FINE_LOCATION)
                == PackageManager.PERMISSION_GRANTED) {
            getAndCompareLocations();
        } else {
            requestPermissionLauncher.launch(ACCESS_FINE_LOCATION);
        }
    }

เมื่อได้รับสิทธิ์ ACCESS_FINE_LOCATION แล้ว ให้ใช้ผู้ให้บริการ Fused Location เพื่อรับตำแหน่งที่ทราบล่าสุดของอุปกรณ์และสร้างออบเจ็กต์ LatLng จากตำแหน่งดังกล่าว

        FusedLocationProviderClient fusedLocationClient =
                LocationServices.getFusedLocationProviderClient(this);

        fusedLocationClient
                .getLastLocation()
                .addOnSuccessListener(
                        this,
                        location -> {
                            // Got last known location. In some rare situations this can be null.
                            if (location == null) {
                                return;
                            }

                            deviceLocation =
                                    new LatLng(location.getLatitude(), location.getLongitude());
                            // ...
                        });
    }

กำลังคำนวณระยะห่างระหว่างที่อยู่ที่ป้อนกับตำแหน่งของอุปกรณ์

ใช้คณิตศาสตร์เพื่อคำนวณระยะห่างระหว่างพิกัดละติจูดและลองจิจูด 2 จุด (ที่อยู่ที่ป้อนและตำแหน่งของอุปกรณ์) ไลบรารีของยูทิลิตี Maps SDK สำหรับ Android แบบโอเพนซอร์สมีเมธอดที่มีประโยชน์ในการคำนวณระยะทางทรงกลมระหว่างจุด 2 จุดบนโลก

ก่อนอื่น ให้ติดตั้งไลบรารีของยูทิลิตี Maps SDK สำหรับ Android โดยเพิ่มทรัพยากร Dependency ต่อไปนี้ลงในไฟล์ build.gradle.kts ของแอป

dependencies {
    // Utility Library for Maps SDK for Android
    // You do not need to add a separate dependency for the Maps SDK for Android
    // since this library builds in the compatible version of the Maps SDK.
    implementation(libs.android.maps.utils)
}

จากนั้นกลับไปที่ไฟล์กิจกรรมหลังจากได้รับตำแหน่งอุปกรณ์ที่ทราบล่าสุด ให้กำหนดรัศมีเป็นเมตรเพื่อพิจารณาว่าตำแหน่งทั้ง 2 แห่ง "ตรงกัน" รัศมีควรมีขนาดใหญ่พอที่จะรองรับความแปรปรวนของความแม่นยำของ GPS และขนาดของสถานที่ตามที่อยู่ที่ผู้ใช้ป้อน เช่น

private static final double acceptableProximity = 150;

จากนั้นใช้เมธอดไลบรารียูทิลิตี computeDistanceBetween() เพื่อคำนวณระยะห่างระหว่างตำแหน่งของอุปกรณ์กับตำแหน่งที่อยู่ซึ่งผู้ใช้ป้อน หากระยะทางอยู่ภายในรัศมีที่กำหนดไว้ข้างต้น ให้ถือว่าสถานที่ตั้งตรงกัน

// Use the computeDistanceBetween function in the Maps SDK for Android
// Utility Library
// to use spherical geometry to compute the distance between two Lat/Lng
// points.
double distanceInMeters =
        computeDistanceBetween(deviceLocation, enteredLocation);
if (distanceInMeters <= acceptedProximity) {
    Log.d(TAG, "location matched");
    // TODO: Display UI based on the locations matching
} else {
    Log.d(TAG, "location not matched");
    // TODO: Display UI based on the locations not matching
}

(ดูตัวอย่างโค้ดแบบเต็ม)

หากที่อยู่และตำแหน่งตรงกัน ให้แสดงการยืนยันในแอปดังที่แสดงในรูปภาพต่อไปนี้

เคล็ดลับในการปรับปรุงการลงชื่อสมัครใช้ที่รวดเร็วและได้รับการยืนยันเพิ่มเติม

อนุญาตให้ผู้ใช้ป้อนที่อยู่ตามชื่อธุรกิจหรือจุดที่น่าสนใจ บริการคาดคะเน "พิมพ์ล่วงหน้า" ไม่เพียงแต่ใช้ได้กับที่อยู่เท่านั้น แต่คุณยังเลือกให้ผู้ใช้ป้อนชื่อธุรกิจหรือสถานที่สำคัญได้ด้วย หากต้องการอนุญาตให้ป้อนทั้งที่อยู่และชื่อสถานที่ประกอบการ ให้นำพร็อพเพอร์ตี้ types ออกจากคำจำกัดความของ Autocomplete

ปรับแต่งรูปลักษณ์ของช่อง Place Autocomplete ให้เข้ากับสไตล์เว็บไซต์ของคุณ หากต้องการควบคุมรูปลักษณ์ของการเติมสถานที่อัตโนมัติในแอปแทนการใช้วิดเจ็ตของ Google คุณสามารถใช้Place Autocomplete แบบเป็นโปรแกรมเพื่อขับเคลื่อน UI ที่คุณสร้างด้วยบริการ Place Autocomplete