A promise is like a contract between functions, where one function agrees to respond once another function completes its task. This allows for the creation of an execution chain that mimics running multiple threads simultaneously. When the deferred object finishes processing, it sends back a status code which can be used by the calling function to determine its next action, either returning its own status code or responding accordingly.

var deferred = $q.defer();

Creating a deferred object here stores callbacks that will be executed later on.

var promise = auth.$changePassword(email, oldPassword, newPassword);

This line sets up the actual function call but does not execute it immediately. By assigning it to a variable, we are able to monitor its progress.

var rValue = promise.then(function(){

The .then() method defines what happens upon successful completion of the promise. Here, an inline function is set to run after the promise succeeds.

}, function(error){

An error handling function is chained after the success function, specifying how to handle failures. It provides a way to respond in case the promise doesn't deliver as expected.

deferred.resolve(promise);

This step instructs the deferred object to execute the code, wait for results, and then trigger either the success or failure actions. The promise is now part of the execution chain, allowing our main code to proceed without waiting around. Once the promise resolves, the appropriate callback will be triggered.

 console.log(rValue); 

In this log statement, we're not directly returning values to avoid blocking the program's flow. Instead, we allow the promises to work asynchronously while the rest of the code continues executing.

return rValue;

Finally, our function returns the promise to the caller, ensuring that the communication between functions remains seamless. Using promises enables us to handle responses without getting stuck waiting for each individual operation to complete. We pass along success or failure information, keeping the code flowing smoothly.

Deferred promises are used in situations where the time needed to complete a task is uncertain or when the exact completion time is not important - typically for asynchronous tasks. The main focus is on receiving the result whenever the code notifies that the task is finished.

It is crucial to return a promise in your function for the deferred you create. The calling code that invokes resetpassword should then wait for this promise to be fulfilled.

function (email, oldPassword, newPassword) {

                var deferred = $q.defer(); //The purpose is to inform the calling code once $changepassword is done. Alternatively, you could directly return the promise from angularfire with different return values.
                var promise = auth.$changePassword(email, oldPassword, newPassword); //$changepassword returns a promise in angularfire
                console.log(deferred); //An object containing resolve, reject, notify, and promise attributes
                promise.then(function(){
                        //success callback
                        deferred.resolve(1); //Upon successful changepassword completion, execution reaches here
                    }, function(error){
                        //error callback
                        deferred.reject(0); //If changepassword fails (e.g., incorrect old password), this block is executed
                    }
                );
                // It's improper to do this.
                console.log(rValue); //This displays another promise? Why not 1 or error.code? How do I access these values??
                return deferred.promise; //Send back the promise to your controller
            }

Your approach involves combining promises, as indicated in the code comments,

$changepassword in angularfire returns a promise

In essence, var deferred = $q.defer() generates a new promise using deferred.promise, but you are essentially already creating a promise with $changePassword. To achieve what you intend to do, simply follow this:

resetpassword: function (email, oldPassword, newPassword) {               
    auth.$changePassword(email, oldPassword, newPassword).then(function(result)       {
        console.log(result); // success here
    }, function(err){
        console.log(err); // error here
    });
}

UPDATE:

Based on Robin's feedback, if you wish to handle the result within a controller instead of invoking the then() function inside the service, return the promise itself to the controller. Here is an example:

Service function:

resetpassword: function (email, oldPassword, newPassword) {
    // send back the promise to the caller
    return auth.$changePassword(email, oldPassword, newPassword);
}

Controller function:

.controller('MyCtrl', ['$scope', 'myService', function($scope, myService){
    // retrieve the promise from the service
    myService.resetPassword($scope.email, $scope.oldPassword, $scope.newPassword).then(function(result){
        // utilize result here
    }, function(err){
        // handle err here
    });
}]);