Android
Firebase

परिचय

टिप्पणियों

फायरबेस उपयोगकर्ता बनाएँ

public class SignUpActivity extends BaseAppCompatActivity {

    @BindView(R.id.tIETSignUpEmail)
    EditText mEditEmail;
    @BindView(R.id.tIETSignUpPassword)
    EditText mEditPassword;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        getSupportActionBar().setDisplayHomeAsUpEnabled(true);
    }

    @OnClick(R.id.btnSignUpSignUp)
    void signUp() {

        FormValidationUtils.clearErrors(mEditEmail, mEditPassword);

        if (FormValidationUtils.isBlank(mEditEmail)) {
            mEditEmail.setError("Please enter email");
            return;
        }

        if (!FormValidationUtils.isEmailValid(mEditEmail)) {
            mEditEmail.setError("Please enter valid email");
            return;
        }

        if (TextUtils.isEmpty(mEditPassword.getText())) {
            mEditPassword.setError("Please enter password");
            return;
        }

        createUserWithEmailAndPassword(mEditEmail.getText().toString(), mEditPassword.getText().toString());
    }

    private void createUserWithEmailAndPassword(String email, String password) {
        DialogUtils.showProgressDialog(this, "", getString(R.string.str_creating_account), false);
        mFirebaseAuth
                .createUserWithEmailAndPassword(email, password)
                .addOnCompleteListener(this, new OnCompleteListener<AuthResult>() {
                    @Override
                    public void onComplete(@NonNull Task<AuthResult> task) {
                        if (!task.isSuccessful()) {
                            Toast.makeText(SignUpActivity.this, task.getException().getMessage(),
                                    Toast.LENGTH_SHORT).show();
                            DialogUtils.dismissProgressDialog();
                        } else {
                            Toast.makeText(SignUpActivity.this, R.string.str_registration_successful, Toast.LENGTH_SHORT).show();
                            DialogUtils.dismissProgressDialog();
                            startActivity(new Intent(SignUpActivity.this, HomeActivity.class));
                        }
                    }
                });
    }

    @Override
    protected int getLayoutResourceId() {
        return R.layout.activity_sign_up;
    }
}

ईमेल और पासवर्ड के साथ फायरबेस उपयोगकर्ता में साइन इन करें

public class LoginActivity extends BaseAppCompatActivity {

    @BindView(R.id.tIETLoginEmail)
    EditText mEditEmail;
    @BindView(R.id.tIETLoginPassword)
    EditText mEditPassword;

    @Override
    protected void onResume() {
        super.onResume();
        FirebaseUser firebaseUser = mFirebaseAuth.getCurrentUser();
        if (firebaseUser != null)
            startActivity(new Intent(this, HomeActivity.class));
    }

    @Override
    protected int getLayoutResourceId() {
        return R.layout.activity_login;
    }

    @OnClick(R.id.btnLoginLogin)
    void onSignInClick() {

        FormValidationUtils.clearErrors(mEditEmail, mEditPassword);

        if (FormValidationUtils.isBlank(mEditEmail)) {
            FormValidationUtils.setError(null, mEditEmail, "Please enter email");
            return;
        }

        if (!FormValidationUtils.isEmailValid(mEditEmail)) {
            FormValidationUtils.setError(null, mEditEmail, "Please enter valid email");
            return;
        }

        if (TextUtils.isEmpty(mEditPassword.getText())) {
            FormValidationUtils.setError(null, mEditPassword, "Please enter password");
            return;
        }

        signInWithEmailAndPassword(mEditEmail.getText().toString(), mEditPassword.getText().toString());
    }

    private void signInWithEmailAndPassword(String email, String password) {
        DialogUtils.showProgressDialog(this, "", getString(R.string.sign_in), false);
        mFirebaseAuth
                .signInWithEmailAndPassword(email, password)
                .addOnCompleteListener(this, new OnCompleteListener<AuthResult>() {
                    @Override
                    public void onComplete(@NonNull Task<AuthResult> task) {

                        DialogUtils.dismissProgressDialog();

                        if (task.isSuccessful()) {
                            Toast.makeText(LoginActivity.this, "Login Successful", Toast.LENGTH_SHORT).show();
                            startActivity(new Intent(LoginActivity.this, HomeActivity.class));
                            finish();
                        } else {
                            Toast.makeText(LoginActivity.this, task.getException().getMessage(),
                                    Toast.LENGTH_SHORT).show();
                        }
                    }
                });
    }

    @OnClick(R.id.btnLoginSignUp)
    void onSignUpClick() {
        startActivity(new Intent(this, SignUpActivity.class));
    }


    @OnClick(R.id.btnLoginForgotPassword)
    void forgotPassword() {
        startActivity(new Intent(this, ForgotPasswordActivity.class));
    }
}

फायरबेस पासवर्ड रीसेट ईमेल भेजें

public class ForgotPasswordActivity extends AppCompatActivity {

    @BindView(R.id.tIETForgotPasswordEmail)
    EditText mEditEmail;
    private FirebaseAuth mFirebaseAuth;
    private FirebaseAuth.AuthStateListener mAuthStateListener;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_forgot_password);
        ButterKnife.bind(this);

        mFirebaseAuth = FirebaseAuth.getInstance();

        mAuthStateListener = new FirebaseAuth.AuthStateListener() {
            @Override
            public void onAuthStateChanged(@NonNull FirebaseAuth firebaseAuth) {
                FirebaseUser firebaseUser = firebaseAuth.getCurrentUser();
                if (firebaseUser != null) {
                    // Do whatever you want with the UserId by firebaseUser.getUid()
                } else {

                }
            }
        };
    }

    @Override
    protected void onStart() {
        super.onStart();
        mFirebaseAuth.addAuthStateListener(mAuthStateListener);
    }

    @Override
    protected void onStop() {
        super.onStop();
        if (mAuthStateListener != null) {
            mFirebaseAuth.removeAuthStateListener(mAuthStateListener);
        }
    }

    @OnClick(R.id.btnForgotPasswordSubmit)
    void onSubmitClick() {

        if (FormValidationUtils.isBlank(mEditEmail)) {
            FormValidationUtils.setError(null, mEditEmail, "Please enter email");
            return;
        }

        if (!FormValidationUtils.isEmailValid(mEditEmail)) {
            FormValidationUtils.setError(null, mEditEmail, "Please enter valid email");
            return;
        }

        DialogUtils.showProgressDialog(this, "", "Please wait...", false);
        mFirebaseAuth.sendPasswordResetEmail(mEditEmail.getText().toString())
                .addOnCompleteListener(new OnCompleteListener<Void>() {
                    @Override
                    public void onComplete(@NonNull Task<Void> task) {
                        DialogUtils.dismissProgressDialog();
                        if (task.isSuccessful()) {
                            Toast.makeText(ForgotPasswordActivity.this, "An email has been sent to you.", Toast.LENGTH_SHORT).show();
                            finish();
                        } else {
                            Toast.makeText(ForgotPasswordActivity.this, task.getException().getMessage(), Toast.LENGTH_SHORT).show();
                        }
                    }
                });
    }
}

फायरबेस उपयोगकर्ताओं के ईमेल को अपडेट करना

public class ChangeEmailActivity extends BaseAppCompatActivity implements ReAuthenticateDialogFragment.OnReauthenticateSuccessListener {

    @BindView(R.id.et_change_email)
    EditText mEditText;
    private FirebaseUser mFirebaseUser;

    @OnClick(R.id.btn_change_email)
    void onChangeEmailClick() {

        FormValidationUtils.clearErrors(mEditText);

        if (FormValidationUtils.isBlank(mEditText)) {
            FormValidationUtils.setError(null, mEditText, "Please enter email");
            return;
        }

        if (!FormValidationUtils.isEmailValid(mEditText)) {
            FormValidationUtils.setError(null, mEditText, "Please enter valid email");
            return;
        }

        changeEmail(mEditText.getText().toString());
    }

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        getSupportActionBar().setDisplayHomeAsUpEnabled(true);
        mFirebaseUser = mFirebaseAuth.getCurrentUser();
    }

    private void changeEmail(String email) {
        DialogUtils.showProgressDialog(this, "Changing Email", "Please wait...", false);
        mFirebaseUser.updateEmail(email)
                .addOnCompleteListener(new OnCompleteListener<Void>() {
                    @Override
                    public void onComplete(@NonNull Task<Void> task) {
                        DialogUtils.dismissProgressDialog();
                        if (task.isSuccessful()) {
                            showToast("Email updated successfully.");
                            return;
                        }

                        if (task.getException() instanceof FirebaseAuthRecentLoginRequiredException) {
                            FragmentManager fm = getSupportFragmentManager();
                            ReAuthenticateDialogFragment reAuthenticateDialogFragment = new ReAuthenticateDialogFragment();
                            reAuthenticateDialogFragment.show(fm, reAuthenticateDialogFragment.getClass().getSimpleName());
                        }
                    }
                });
    }

    @Override
    protected int getLayoutResourceId() {
        return R.layout.activity_change_email;
    }

    @Override
    public void onReauthenticateSuccess() {
        changeEmail(mEditText.getText().toString());
    }
}

पासवर्ड बदलें

public class ChangePasswordActivity extends BaseAppCompatActivity implements ReAuthenticateDialogFragment.OnReauthenticateSuccessListener {
    @BindView(R.id.et_change_password)
    EditText mEditText;
    private FirebaseUser mFirebaseUser;

    @OnClick(R.id.btn_change_password)
    void onChangePasswordClick() {

        FormValidationUtils.clearErrors(mEditText);

        if (FormValidationUtils.isBlank(mEditText)) {
            FormValidationUtils.setError(null, mEditText, "Please enter password");
            return;
        }

        changePassword(mEditText.getText().toString());
    }

    private void changePassword(String password) {
        DialogUtils.showProgressDialog(this, "Changing Password", "Please wait...", false);
        mFirebaseUser.updatePassword(password)
                .addOnCompleteListener(new OnCompleteListener<Void>() {
                    @Override
                    public void onComplete(@NonNull Task<Void> task) {
                        DialogUtils.dismissProgressDialog();
                        if (task.isSuccessful()) {
                            showToast("Password updated successfully.");
                            return;
                        }

                        if (task.getException() instanceof FirebaseAuthRecentLoginRequiredException) {
                            FragmentManager fm = getSupportFragmentManager();
                            ReAuthenticateDialogFragment reAuthenticateDialogFragment = new ReAuthenticateDialogFragment();
                            reAuthenticateDialogFragment.show(fm, reAuthenticateDialogFragment.getClass().getSimpleName());
                        }
                    }
                });
    }

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        getSupportActionBar().setDisplayHomeAsUpEnabled(true);
        mFirebaseUser = mFirebaseAuth.getCurrentUser();
    }

    @Override
    protected int getLayoutResourceId() {
        return R.layout.activity_change_password;
    }

    @Override
    public void onReauthenticateSuccess() {
        changePassword(mEditText.getText().toString());
    }
}

उपयोगकर्ता को फिर से प्रमाणित करें

public class ReAuthenticateDialogFragment extends DialogFragment {

    @BindView(R.id.et_dialog_reauthenticate_email)
    EditText mEditTextEmail;
    @BindView(R.id.et_dialog_reauthenticate_password)
    EditText mEditTextPassword;
    private OnReauthenticateSuccessListener mOnReauthenticateSuccessListener;

    @OnClick(R.id.btn_dialog_reauthenticate)
    void onReauthenticateClick() {

        FormValidationUtils.clearErrors(mEditTextEmail, mEditTextPassword);

        if (FormValidationUtils.isBlank(mEditTextEmail)) {
            FormValidationUtils.setError(null, mEditTextEmail, "Please enter email");
            return;
        }

        if (!FormValidationUtils.isEmailValid(mEditTextEmail)) {
            FormValidationUtils.setError(null, mEditTextEmail, "Please enter valid email");
            return;
        }

        if (TextUtils.isEmpty(mEditTextPassword.getText())) {
            FormValidationUtils.setError(null, mEditTextPassword, "Please enter password");
            return;
        }

        reauthenticateUser(mEditTextEmail.getText().toString(), mEditTextPassword.getText().toString());
    }

    private void reauthenticateUser(String email, String password) {
        DialogUtils.showProgressDialog(getActivity(), "Re-Authenticating", "Please wait...", false);
        FirebaseUser firebaseUser = FirebaseAuth.getInstance().getCurrentUser();
        AuthCredential authCredential = EmailAuthProvider.getCredential(email, password);
        firebaseUser.reauthenticate(authCredential)
                .addOnCompleteListener(new OnCompleteListener<Void>() {
                    @Override
                    public void onComplete(@NonNull Task<Void> task) {
                        DialogUtils.dismissProgressDialog();
                        if (task.isSuccessful()) {
                            mOnReauthenticateSuccessListener.onReauthenticateSuccess();
                            dismiss();
                        } else {
                            ((BaseAppCompatActivity) getActivity()).showToast(task.getException().getMessage());
                        }
                    }
                });
    }

    @Override
    public void onAttach(Context context) {
        super.onAttach(context);
        mOnReauthenticateSuccessListener = (OnReauthenticateSuccessListener) context;
    }

    @OnClick(R.id.btn_dialog_reauthenticate_cancel)
    void onCancelClick() {
        dismiss();
    }

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
                             Bundle savedInstanceState) {
        View view = inflater.inflate(R.layout.dialog_reauthenticate, container);
        ButterKnife.bind(this, view);
        return view;
    }

    @Override
    public void onResume() {
        super.onResume();
        Window window = getDialog().getWindow();
        window.setLayout(WindowManager.LayoutParams.MATCH_PARENT, WindowManager.LayoutParams.WRAP_CONTENT);
    }

    interface OnReauthenticateSuccessListener {
        void onReauthenticateSuccess();
    }
}

फायरबेस स्टोरेज ऑपरेशंस

इस उदाहरण के साथ, आप निम्नलिखित कार्य कर पाएंगे:

1. फायरबेस स्टोरेज से कनेक्ट करें
2. "चित्र" नाम की एक निर्देशिका बनाएँ
3. चित्र निर्देशिका में एक फ़ाइल अपलोड करें
4. छवियों निर्देशिका से एक फ़ाइल डाउनलोड करें
5. छवियों निर्देशिका से एक फ़ाइल हटाएँ

public class MainActivity extends AppCompatActivity {

    private static final int REQUEST_CODE_PICK_IMAGE = 1;
    private static final int PERMISSION_READ_WRITE_EXTERNAL_STORAGE = 2;

    private FirebaseStorage mFirebaseStorage;
    private StorageReference mStorageReference;
    private StorageReference mStorageReferenceImages;
    private Uri mUri;
    private ImageView mImageView;
    private ProgressDialog mProgressDialog;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
        mImageView = (ImageView) findViewById(R.id.imageView);
        setSupportActionBar(toolbar);

        // Create an instance of Firebase Storage
        mFirebaseStorage = FirebaseStorage.getInstance();
    }

    private void pickImage() {
        Intent intent = new Intent(Intent.ACTION_PICK, android.provider.MediaStore.Images.Media.EXTERNAL_CONTENT_URI);
        intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
        intent.addFlags(Intent.FLAG_GRANT_WRITE_URI_PERMISSION);
        startActivityForResult(intent, REQUEST_CODE_PICK_IMAGE);
    }

    @Override
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
        if (resultCode == RESULT_OK) {
            if (requestCode == REQUEST_CODE_PICK_IMAGE) {
                String filePath = FileUtil.getPath(this, data.getData());
                mUri = Uri.fromFile(new File(filePath));
                uploadFile(mUri);
            }
        }
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        if (requestCode == PERMISSION_READ_WRITE_EXTERNAL_STORAGE) {
            if (grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                pickImage();
            }
        }
    }

    private void showProgressDialog(String title, String message) {
        if (mProgressDialog != null && mProgressDialog.isShowing())
            mProgressDialog.setMessage(message);
        else
            mProgressDialog = ProgressDialog.show(this, title, message, true, false);
    }

    private void hideProgressDialog() {
        if (mProgressDialog != null && mProgressDialog.isShowing()) {
            mProgressDialog.dismiss();
        }
    }

    private void showToast(String message) {
        Toast.makeText(this, message, Toast.LENGTH_SHORT).show();
    }

    public void showHorizontalProgressDialog(String title, String body) {

        if (mProgressDialog != null && mProgressDialog.isShowing()) {
            mProgressDialog.setTitle(title);
            mProgressDialog.setMessage(body);
        } else {
            mProgressDialog = new ProgressDialog(this);
            mProgressDialog.setTitle(title);
            mProgressDialog.setMessage(body);
            mProgressDialog.setIndeterminate(false);
            mProgressDialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
            mProgressDialog.setProgress(0);
            mProgressDialog.setMax(100);
            mProgressDialog.setCancelable(false);
            mProgressDialog.show();
        }
    }

    public void updateProgress(int progress) {
        if (mProgressDialog != null && mProgressDialog.isShowing()) {
            mProgressDialog.setProgress(progress);
        }
    }

    /**
     * Step 1: Create a Storage
     *
     * @param view
     */
    public void onCreateReferenceClick(View view) {
        mStorageReference = mFirebaseStorage.getReferenceFromUrl("gs://**something**.appspot.com");
        showToast("Reference Created Successfully.");
        findViewById(R.id.button_step_2).setEnabled(true);
    }

    /**
     * Step 2: Create a directory named "Images"
     *
     * @param view
     */
    public void onCreateDirectoryClick(View view) {
        mStorageReferenceImages = mStorageReference.child("images");
        showToast("Directory 'images' created Successfully.");
        findViewById(R.id.button_step_3).setEnabled(true);
    }

    /**
     * Step 3: Upload an Image File and display it on ImageView
     *
     * @param view
     */
    public void onUploadFileClick(View view) {
        if (ContextCompat.checkSelfPermission(MainActivity.this, Manifest.permission.READ_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED || ActivityCompat.checkSelfPermission(MainActivity.this, Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED)
            ActivityCompat.requestPermissions(MainActivity.this, new String[]{Manifest.permission.READ_EXTERNAL_STORAGE, Manifest.permission.WRITE_EXTERNAL_STORAGE}, PERMISSION_READ_WRITE_EXTERNAL_STORAGE);
        else {
            pickImage();
        }
    }

    /**
     * Step 4: Download an Image File and display it on ImageView
     *
     * @param view
     */
    public void onDownloadFileClick(View view) {
        downloadFile(mUri);
    }

    /**
     * Step 5: Delete am Image File and remove Image from ImageView
     *
     * @param view
     */
    public void onDeleteFileClick(View view) {
        deleteFile(mUri);
    }

    private void showAlertDialog(Context ctx, String title, String body, DialogInterface.OnClickListener okListener) {

        if (okListener == null) {
            okListener = new DialogInterface.OnClickListener() {

                public void onClick(DialogInterface dialog, int which) {
                    dialog.cancel();
                }
            };
        }

        AlertDialog.Builder builder = new AlertDialog.Builder(ctx).setMessage(body).setPositiveButton("OK", okListener).setCancelable(false);

        if (!TextUtils.isEmpty(title)) {
            builder.setTitle(title);
        }

        builder.show();
    }

    private void uploadFile(Uri uri) {
        mImageView.setImageResource(R.drawable.placeholder_image);

        StorageReference uploadStorageReference = mStorageReferenceImages.child(uri.getLastPathSegment());
        final UploadTask uploadTask = uploadStorageReference.putFile(uri);
        showHorizontalProgressDialog("Uploading", "Please wait...");
        uploadTask
                .addOnSuccessListener(new OnSuccessListener<UploadTask.TaskSnapshot>() {
                    @Override
                    public void onSuccess(UploadTask.TaskSnapshot taskSnapshot) {
                        hideProgressDialog();
                        Uri downloadUrl = taskSnapshot.getDownloadUrl();
                        Log.d("MainActivity", downloadUrl.toString());
                        showAlertDialog(MainActivity.this, "Upload Complete", downloadUrl.toString(), new DialogInterface.OnClickListener() {
                            @Override
                            public void onClick(DialogInterface dialogInterface, int i) {
                                findViewById(R.id.button_step_3).setEnabled(false);
                                findViewById(R.id.button_step_4).setEnabled(true);
                            }
                        });

                        Glide.with(MainActivity.this)
                                .load(downloadUrl)
                                .into(mImageView);
                    }
                })
                .addOnFailureListener(new OnFailureListener() {
                    @Override
                    public void onFailure(@NonNull Exception exception) {
                        exception.printStackTrace();
                        // Handle unsuccessful uploads
                        hideProgressDialog();
                    }
                })
                .addOnProgressListener(MainActivity.this, new OnProgressListener<UploadTask.TaskSnapshot>() {
                    @Override
                    public void onProgress(UploadTask.TaskSnapshot taskSnapshot) {
                        int progress = (int) (100 * (float) taskSnapshot.getBytesTransferred() / taskSnapshot.getTotalByteCount());
                        Log.i("Progress", progress + "");
                        updateProgress(progress);
                    }
                });
    }

    private void downloadFile(Uri uri) {
        mImageView.setImageResource(R.drawable.placeholder_image);
        final StorageReference storageReferenceImage = mStorageReferenceImages.child(uri.getLastPathSegment());
        File mediaStorageDir = new File(Environment.getExternalStoragePublicDirectory(
                Environment.DIRECTORY_PICTURES), "Firebase Storage");
        if (!mediaStorageDir.exists()) {
            if (!mediaStorageDir.mkdirs()) {
                Log.d("MainActivity", "failed to create Firebase Storage directory");
            }
        }

        final File localFile = new File(mediaStorageDir, uri.getLastPathSegment());
        try {
            localFile.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
        }

        showHorizontalProgressDialog("Downloading", "Please wait...");
        storageReferenceImage.getFile(localFile).addOnSuccessListener(new OnSuccessListener<FileDownloadTask.TaskSnapshot>() {
            @Override
            public void onSuccess(FileDownloadTask.TaskSnapshot taskSnapshot) {
                hideProgressDialog();
                showAlertDialog(MainActivity.this, "Download Complete", localFile.getAbsolutePath(), new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialogInterface, int i) {
                        findViewById(R.id.button_step_4).setEnabled(false);
                        findViewById(R.id.button_step_5).setEnabled(true);
                    }
                });

                Glide.with(MainActivity.this)
                        .load(localFile)
                        .into(mImageView);
            }
        }).addOnFailureListener(new OnFailureListener() {
            @Override
            public void onFailure(@NonNull Exception exception) {
                // Handle any errors
                hideProgressDialog();
                exception.printStackTrace();
            }
        }).addOnProgressListener(new OnProgressListener<FileDownloadTask.TaskSnapshot>() {
            @Override
            public void onProgress(FileDownloadTask.TaskSnapshot taskSnapshot) {
                int progress = (int) (100 * (float) taskSnapshot.getBytesTransferred() / taskSnapshot.getTotalByteCount());
                Log.i("Progress", progress + "");
                updateProgress(progress);
            }
        });
    }

    private void deleteFile(Uri uri) {
        showProgressDialog("Deleting", "Please wait...");
        StorageReference storageReferenceImage = mStorageReferenceImages.child(uri.getLastPathSegment());
        storageReferenceImage.delete().addOnSuccessListener(new OnSuccessListener<Void>() {
            @Override
            public void onSuccess(Void aVoid) {
                hideProgressDialog();
                showAlertDialog(MainActivity.this, "Success", "File deleted successfully.", new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialogInterface, int i) {
                        mImageView.setImageResource(R.drawable.placeholder_image);
                        findViewById(R.id.button_step_3).setEnabled(true);
                        findViewById(R.id.button_step_4).setEnabled(false);
                        findViewById(R.id.button_step_5).setEnabled(false);
                    }
                });
                File mediaStorageDir = new File(Environment.getExternalStoragePublicDirectory(
                        Environment.DIRECTORY_PICTURES), "Firebase Storage");
                if (!mediaStorageDir.exists()) {
                    if (!mediaStorageDir.mkdirs()) {
                        Log.d("MainActivity", "failed to create Firebase Storage directory");
                    }
                }
                deleteFiles(mediaStorageDir);
            }
        }).addOnFailureListener(new OnFailureListener() {
            @Override
            public void onFailure(@NonNull Exception exception) {
                hideProgressDialog();
                exception.printStackTrace();
            }
        });
    }

    private void deleteFiles(File directory) {
        if (directory.isDirectory())
            for (File child : directory.listFiles())
                child.delete();
    }
}

डिफ़ॉल्ट रूप से, फायरबेस स्टोरेज नियम प्रमाणीकरण प्रतिबंध लागू करता है। यदि उपयोगकर्ता प्रमाणित होता है, तभी वह फायरबेस स्टोरेज पर परिचालन कर सकता है, अन्यथा वह नहीं कर सकता। मैंने संग्रहण नियमों को अपडेट करके इस डेमो में प्रमाणीकरण भाग को अक्षम कर दिया है। पहले, नियम जैसे दिख रहे थे:

 service firebase.storage {
   match /b/**something**.appspot.com/o {
     match /{allPaths=**} {
       allow read, write: if request.auth != null;
     }
   }
 }

लेकिन मैं प्रमाणीकरण को छोड़ने के लिए बदल गया:

service firebase.storage {
  match /b/**something**.appspot.com/o {
    match /{allPaths=**} {
      allow read, write;
    }
  }
}

फायरबेस क्लाउड मेसेजिंग

सबसे पहले आपको इस विषय में बताए गए चरणों का पालन करते हुए अपने एंड्रॉइड प्रोजेक्ट में फायरबेस को जोड़ने की आवश्यकता है।

फायरबेस और एफसीएम एसडीके की स्थापना करें

अपने ऐप-स्तरीय build.gradle फ़ाइल में FCM निर्भरता जोड़ें

dependencies {
 compile 'com.google.firebase:firebase-messaging:11.0.4'
}

और बहुत नीचे (यह महत्वपूर्ण है) जोड़ें:

// ADD THIS AT THE BOTTOM
apply plugin: 'com.google.gms.google-services'

अपने एप्लिकेशन मेनिफेस्ट को संपादित करें

अपने ऐप के प्रकटन में निम्नलिखित जोड़ें:

• एक सेवा जो FirebaseMessagingService विस्तार करती है। यदि आप पृष्ठभूमि में ऐप्स पर सूचनाएं प्राप्त करने से परे कोई संदेश हैंडलिंग करना चाहते हैं तो यह आवश्यक है।

• एक ऐसी सेवा जो पंजीकरण टोकनों के निर्माण, रोटेशन और अद्यतन को संभालने के लिए FirebaseInstanceIdService का विस्तार करती है।

उदाहरण के लिए:

    <service
        android:name=".MyInstanceIdListenerService">
        <intent-filter>
            <action android:name="com.google.firebase.INSTANCE_ID_EVENT"/>
        </intent-filter>
    </service>
    <service
        android:name=".MyFcmListenerService">
        <intent-filter>
            <action android:name="com.google.firebase.MESSAGING_EVENT" />
        </intent-filter>
    </service>

यहाँ 2 सेवाओं के सरल कार्यान्वयन हैं।

वर्तमान पंजीकरण टोकन को पुनः प्राप्त करने के लिए FirebaseInstanceIdService क्लास का विस्तार करें और onTokenRefresh() विधि को ओवरराइड करें:

public class MyInstanceIdListenerService extends FirebaseInstanceIdService {

    // Called if InstanceID token is updated. Occurs if the security of the previous token had been
    // compromised. This call is initiated by the InstanceID provider.
    @Override
    public void onTokenRefresh() {
        // Get updated InstanceID token.
        String refreshedToken = FirebaseInstanceId.getInstance().getToken();

        // Send this token to your server or store it locally
    }
}

संदेश प्राप्त करने के लिए, एक ऐसी सेवा का उपयोग करें जो FirebaseMessagingService को onMessageReceived और onMessageReceived विधि को ओवरराइड करती है।

public class MyFcmListenerService extends FirebaseMessagingService {
    
    /**
     * Called when message is received.
     *
     * @param remoteMessage Object representing the message received from Firebase Cloud Messaging.
     */
    @Override
    public void onMessageReceived(RemoteMessage remoteMessage) {
        String from = remoteMessage.getFrom();

        // Check if message contains a data payload.
        if (remoteMessage.getData().size() > 0) {
            Log.d(TAG, "Message data payload: " + remoteMessage.getData());
            Map<String, String> data = remoteMessage.getData();
        }

        // Check if message contains a notification payload.
        if (remoteMessage.getNotification() != null) {
            Log.d(TAG, "Message Notification Body: " + remoteMessage.getNotification().getBody());
        }

        // do whatever you want with this, post your own notification, or update local state
    }

Firebase में उपयोगकर्ता को उनके व्यवहार जैसे "AppVersion, नि: शुल्क उपयोगकर्ता, खरीद उपयोगकर्ता, या कोई विशिष्ट नियम" द्वारा समूहीकृत किया जा सकता है और फिर fireBase में Topic फ़ीचर भेजकर विशिष्ट समूह को सूचना भेज सकते हैं।
विषय के उपयोग में उपयोगकर्ता को पंजीकृत करने के लिए

FirebaseMessaging.getInstance().subscribeToTopic("Free");

फिर फायरबेस कंसोल में, विषय के नाम से अधिसूचना भेजें

समर्पित विषय फायरबेस क्लाउड मेसेजिंग में अधिक जानकारी।

अपने Android प्रोजेक्ट में Firebase जोड़ें

फायरबेस परियोजना बनाने और इसे एक एंड्रॉइड ऐप से जोड़ने के लिए आवश्यक सरलीकृत चरण ( आधिकारिक दस्तावेज पर आधारित) यहां दिए गए हैं।

अपने ऐप में फायरबेस जोड़ें

1. Firebase कंसोल में एक Firebase प्रोजेक्ट बनाएं और Create New Project पर क्लिक करें ।

2. अपने Android ऐप में Add Firebase पर क्लिक करें और सेटअप चरणों का पालन करें।

3. संकेत दिए जाने पर, अपने ऐप के पैकेज का नाम दर्ज करें।
   आपके ऐप का उपयोग करने वाले पूरी तरह से योग्य पैकेज नाम दर्ज करना महत्वपूर्ण है; यह केवल तब सेट किया जा सकता है जब आप अपने फायरबेस प्रोजेक्ट में कोई ऐप जोड़ते हैं।

4. अंत में, आप एक google-services.json फ़ाइल डाउनलोड करेंगे। आप किसी भी समय इस फ़ाइल को फिर से डाउनलोड कर सकते हैं।

5. यदि आपने ऐसा पहले से नहीं किया है, तो अपने प्रोजेक्ट के मॉड्यूल फोल्डर, आमतौर पर app/ में google-services.json फाइल को कॉपी करें।

अगला कदम प्रोजेक्ट में फायरबेस लाइब्रेरी को एकीकृत करने के लिए एसडीके को जोड़ना है।

एसडीके जोड़ें

अपने स्वयं के प्रोजेक्ट में फायरबेस लाइब्रेरी को एकीकृत करने के लिए, आपको अपने एंड्रॉइड स्टूडियो प्रोजेक्ट को तैयार करने के लिए कुछ बुनियादी कार्यों को करने की आवश्यकता है। हो सकता है कि आपने अपने ऐप में Firebase जोड़ने के हिस्से के रूप में ऐसा किया हो।

1. अपनी रूट-लेवल build.gradle फ़ाइल में नियम जोड़ें, जिसमें Google- build.gradle प्लगइन शामिल हो :

buildscript {
    // ...
    dependencies {
        // ...
        classpath 'com.google.gms:google-services:3.1.0'
    }
}

फिर, अपने मॉड्यूल ग्रैडल फ़ाइल (आमतौर पर app/build.gradle ) में, app/build.gradle प्लगइन को सक्षम करने के लिए फ़ाइल के निचले भाग में लागू प्लगइन लाइन जोड़ें:

apply plugin: 'com.android.application'

android {
  // ...
}

dependencies {
  // ...
  compile 'com.google.firebase:firebase-core:11.0.4'
}

// ADD THIS AT THE BOTTOM
apply plugin: 'com.google.gms.google-services'

अंतिम चरण अलग-अलग फायरबेस सुविधाओं के लिए उपलब्ध एक या अधिक पुस्तकालयों का उपयोग करके फायरबेस एसडीके के लिए निर्भरता को जोड़ना है।

Firebase Realtime Database: डेटा को कैसे सेट / प्राप्त करें

नोट: आइए उदाहरण के लिए कुछ अनाम प्रमाणीकरण सेट करें

{
  "rules": {
    ".read": "auth != null",
    ".write": "auth != null"
  }
}

एक बार यह हो जाने के बाद, अपने डेटाबेस पते को संपादित करके एक बच्चा बनाएं। उदाहरण के लिए:

https://your-project.firebaseio.com/ से https://your-project.firebaseio.com/chat

हम अपने Android डिवाइस से इस स्थान पर डेटा डालेंगे। आपको डेटाबेस संरचना (टैब, फ़ील्ड ... आदि) बनाने की ज़रूरत नहीं है , यह स्वचालित रूप से तब बनेगा जब आप जावा ऑब्जेक्ट को फायरबेस भेज देंगे!

एक जावा ऑब्जेक्ट बनाएं जिसमें वे सभी विशेषताएँ हों जो आप डेटाबेस में भेजना चाहते हैं:

public class ChatMessage {
    private String username;
    private String message;

    public ChatMessage(String username, String message) {
        this.username = username;
        this.message = message;
    }

    public ChatMessage() {} // you MUST have an empty constructor

    public String getUsername() {
        return username;
    }

    public String getMessage() {
        return message;
    }
}

फिर आपकी गतिविधि में:

if (FirebaseAuth.getInstance().getCurrentUser() == null) {
        FirebaseAuth.getInstance().signInAnonymously().addOnCompleteListener(new OnCompleteListener<AuthResult>() {
            @Override
            public void onComplete(@NonNull Task<AuthResult> task) {
                if (task.isComplete() && task.isSuccessful()){
                    FirebaseDatabase database = FirebaseDatabase.getInstance();
                    DatabaseReference reference = database.getReference("chat"); // reference is 'chat' because we created the database at /chat
                }
            }
        });
}

मान भेजने के लिए:

ChatMessage msg = new ChatMessage("user1", "Hello World!");
reference.push().setValue(msg);

डेटाबेस में होने वाले परिवर्तन प्राप्त करने के लिए:

reference.addChildEventListener(new ChildEventListener() {
    @Override
    public void onChildAdded(DataSnapshot dataSnapshot, String s) {
        ChatMessage msg = dataSnapshot.getValue(ChatMessage.class);
        Log.d(TAG, msg.getUsername()+" "+msg.getMessage());
    }

    public void onChildChanged(DataSnapshot dataSnapshot, String s) {}
    public void onChildRemoved(DataSnapshot dataSnapshot) {}
    public void onChildMoved(DataSnapshot dataSnapshot, String s) {}
    public void onCancelled(DatabaseError databaseError) {}
});

एफसीएम आधारित सूचनाओं का डेमो

यह उदाहरण दिखाता है कि फायरबेस क्लाउड मैसेजिंग (FCM) प्लेटफॉर्म का उपयोग कैसे करें। FCM Google क्लाउड मैसेजिंग (GCM) का उत्तराधिकारी है। इसे ऐप उपयोगकर्ताओं से C2D_MESSAGE अनुमतियों की आवश्यकता नहीं है।

एफसीएम को एकीकृत करने के चरण निम्नानुसार हैं।

1. Android स्टूडियो में नमूना हैलो वर्ल्ड प्रोजेक्ट बनाएं आपका Android स्टूडियो स्क्रीन निम्न चित्र की तरह दिखाई देगा।

2. अगला कदम फायरबेस परियोजना स्थापित करना है। Https://console.firebase.google.com पर जाएं और एक समान नाम वाला प्रोजेक्ट बनाएं, ताकि आप इसे आसानी से ट्रैक कर सकें।

3. अब समय है कि आप अपने द्वारा बनाए गए एंड्रॉइड प्रोजेक्ट के सैंपल में फायरबेस जोड़ें। आपको अपनी परियोजना के पैकेज नाम और डीबग हस्ताक्षर प्रमाणपत्र SHA-1 (वैकल्पिक) की आवश्यकता होगी।

   ए। पैकेज का नाम - यह एंड्रॉइड मैनिफ़ेस्ट XML फ़ाइल से पाया जा सकता है।

   ख। SHA-1 प्रमाणपत्र पर हस्ताक्षर करते हुए डीबग - यह टर्मिनल में निम्नलिखित कमांड चलाकर पाया जा सकता है।

keytool -list -v -keystore ~/.android/debug.keystore -alias androiddebugkey -storepass android -keypass android

इस जानकारी को फायरबेस कंसोल में दर्ज करें और ऐप को फायरबेस प्रोजेक्ट में जोड़ें। एक बार जब आप ऐप बटन पर क्लिक करते हैं, तो आपका ब्राउज़र स्वचालित रूप से "google-services.json" नामक एक JSON फ़ाइल डाउनलोड करेगा।

4. अब Google- services.json फ़ाइल को कॉपी करें जिसे आपने अभी अपने एंड्रॉइड ऐप मॉड्यूल रूट डायरेक्टरी में डाउनलोड किया है।

5. आगे बढ़ने पर फायरबेस कंसोल पर दिए गए निर्देशों का पालन करें। ए। अपने प्रोजेक्ट स्तर build.gradle के लिए निम्नलिखित कोड लाइन जोड़ें

   dependencies{ classpath 'com.google.gms:google-services:3.1.0' .....

   ख। अपने एप्लिकेशन स्तर build.gradle के अंत में निम्नलिखित कोड लाइन जोड़ें।

       //following are the dependencies to be added
       compile 'com.google.firebase:firebase-messaging:11.0.4'
       compile 'com.android.support:multidex:1.0.1'
   }
   // this line goes to the end of the file
   apply plugin: 'com.google.gms.google-services'
   

   सी। Android स्टूडियो आपको प्रोजेक्ट सिंक करने के लिए कहेगा। अब सिंक पर क्लिक करें।

6. अगला काम दो सेवाओं को जोड़ना है। ए। निम्नलिखित के रूप में आशय-फ़िल्टर के साथ एक FirebaseMessagingService का विस्तार

       <intent-filter>
           <action android:name="com.google.firebase.MESSAGING_EVENT"/>
       </intent-filter>
   

   ख। एक फैली हुई FirebaseInstanceIDService।

   <intent-filter>
       <action android:name="com.google.firebase.INSTANCE_ID_EVENT"/>
   </intent-filter>
   

7. FirebaseMessagingService कोड इस तरह दिखना चाहिए।

   import android.app.Service;
   import android.content.Intent;
   import android.os.IBinder;
   
   import com.google.firebase.messaging.FirebaseMessagingService;
   
   public class MyFirebaseMessagingService extends FirebaseMessagingService {
       public MyFirebaseMessagingService() {
       }
   }
   

8. FirebaseInstanceIdService को इस तरह दिखना चाहिए।

   import android.app.Service;
   import android.content.Intent;
   import android.os.IBinder;
   
   import com.google.firebase.iid.FirebaseInstanceIdService;
   
   public class MyFirebaseInstanceIDService extends FirebaseInstanceIdService {
       public MyFirebaseInstanceIDService() {
       }
   }
   

9. अब डिवाइस पंजीकरण टोकन को पकड़ने का समय है। MainActivity की ऑनक्रिएट विधि में कोड की निम्नलिखित पंक्ति जोड़ें।

   String token = FirebaseInstanceId.getInstance().getToken();
   Log.d("FCMAPP", "Token is "+token);
   

10. एक बार जब हमारे पास टोकन पहुंच जाता है, तो हम सूचना भेजने के लिए फायरबेस कंसोल का उपयोग कर सकते हैं। अपने एंड्रॉइड हैंडसेट पर ऐप चलाएं।

फायरबेस कंसोल में सूचना पर क्लिक करें और यूआई आपको अपना पहला संदेश भेजने में मदद करेगा। Firebase सिंगल डिवाइस पर संदेश भेजने के लिए कार्यक्षमता प्रदान करता है (हमारे द्वारा कैप्चर की गई डिवाइस टोकन आईडी का उपयोग करके) या हमारे ऐप का उपयोग करने वाले सभी उपयोगकर्ताओं या उपयोगकर्ताओं के विशिष्ट समूह के लिए। एक बार जब आप अपना पहला संदेश भेजते हैं, तो आपके मोबाइल की स्क्रीन निम्नलिखित की तरह दिखनी चाहिए।

धन्यवाद

फायरबेस साइन आउट

चर का प्रारंभ

private GoogleApiClient mGoogleApiClient;

आपको इस कोड को onCreate () पद्धति में सभी को लिखना होगा, जब यू साइनआउट बटन डालते हैं।

 mGoogleApiClient = new GoogleApiClient.Builder(this)
            .enableAutoManage(this /* FragmentActivity */, this /* OnConnectionFailedListener */)
            .addApi(Auth.GOOGLE_SIGN_IN_API)
            .build();

साइनआउट बटन पर कोड नीचे रखें।

Auth.GoogleSignInApi.signOut(mGoogleApiClient).setResultCallback(
                    new ResultCallback<Status>() {
                        @Override
                        public void onResult(Status status) {
                            FirebaseAuth.getInstance().signOut();
                            Intent i1 = new Intent(MainActivity.this, GoogleSignInActivity.class);
                            startActivity(i1);
                            Toast.makeText(MainActivity.this, "Logout Successfully!", Toast.LENGTH_SHORT).show();
                        }
                    });