Few main things remember to test an Android Application which is mention below:

1. Functional testing test cases

There are many hands involved in creating a mobile app. These stakeholders may have different expectations. Functional testing determines whether a mobile app complies with these various requirements and uses. Examine and validate all functions, features, and competencies of a product.

Twelve functional test case scenario questions:

1. Does the application work as intended when starting and stopping?
2. Does the app work accordingly on different mobile and operating system versions?
3. Does the app behave accordingly in the event of external interruptions?
4. (i.e. receiving SMS, minimized during an incoming phone call, etc.)
5. Can the user download and install the app with no problem?
6. Can the device multitask as expected when the app is in use or running in the background?
7. Applications work satisfactorily after installing the app.
8. Do social networking options like sharing, publishing, etc. work as needed?
9. Do mandatory fields work as required? Does the app support payment gateway transactions?
10. Are page scrolling scenarios working as expected?
11. Navigate between different modules as expected.
12. Are appropriate error messages received if necessary?

There are two ways to run functional testing: scripted and exploratory.

Scripted

Running scripted tests is just that - a structured scripted activity in which testers follow predetermined steps. This allows QA testers to compare actual results with expected ones. These types of tests are usually confirmatory in nature, meaning that you are confirming that the application can perform the desired function. Testers generally run into more problems when they have more flexibility in test design.

Exploratory

Exploratory testing investigates and finds bugs and errors on the fly. It allows testers to manually discover software problems that are often unforeseen; where the QA team is testing so that most users actually use the app. learning, test design, test execution, and interpretation of test results as complementary activities that run in parallel throughout the project. Related: Scripted Testing Vs Exploratory Testing: Is One Better Than The Other?

2. Performance testing test cases

The primary goal of benchmarking is to ensure the performance and stability of your mobile application

Seven Performance test case scenarios ensure:

1. Can the app handle the expected cargo volumes?
2. What are the various mobile app and infrastructure bottlenecks preventing the app from performing as expected?
3. Is the response time as expected? Are battery drain, memory leaks, GPS, and camera performance within the required guidelines?
4. Current network coverage able to support the app at peak, medium, and minimum user levels?
5. Are there any performance issues if the network changes from/to Wi-Fi and 2G / 3G / 4G?
6. How does the app behave during the intermittent phases of connectivity?
7. Existing client-server configurations that provide the optimum performance level?

3. Battery usage test cases

While battery usage is an important part of performance testing, mobile app developers must make it a top priority. Apps are becoming more and more demanding in terms of computing power. So, when developing your mobile app testing strategy, understand that battery-draining mobile apps degrade the user experience.

Device hardware - including battery life - varies by model and manufacturer. Therefore, QA testing teams must have a variety of new and older devices on hand in their mobile device laboratory. In addition, the test environment must replicate real applications such as operating system, network conditions (3G, 4G, WLAN, roaming), and multitasking from the point of view of the battery consumption test.

Seven battery usage test case scenarios to pay special attention to:

1. Mobile app power consumption
2. User interface design that uses intense graphics or results in unnecessarily high database queries
3. Battery life can allow the app to operate at expected charge volumes
4. Battery low and high-performance requirements
5. Application operation is used when the battery is removed Battery usage and data leaks
6. New features and updates do not introduce new battery usage and data
7. Related: The secret art of battery testing on Android

4. Usability Testing Test Cases

Usability testing of mobile applications provides end-users with an intuitive and user-friendly interface. This type of testing is usually done manually, to ensure the app is easy to use and meets real users' expectations.

Ten usability test case scenarios ensure:

1. The buttons are of a user-friendly size.
2. The position, style, etc. of the buttons are consistent within the app
3. Icons are consistent within the application
4. The zoom in and out functions work as expected
5. The keyboard can be minimized and maximized easily.
6. The action or touching the wrong item can be easily undone.
7. Context menus are not overloaded.
8. Verbiage is simple, clear, and easily visible.
9. The end-user can easily find the help menu or user manual in case of need.
10. Related: High impact usability testing that is actually doable

We will see more points in our next articles.

Snackbars are fairly common in the Android app. Almost every app uses a snack bar to display some information about what's going on in the app. You can consider Snackbar as an alternative or the best version of Toasts in Android.

Step 1: Using a normal Snackbar

To use Snackbar in your app, you just have to have the material design dependency in your app. Add Material design dependency to your build.Gradle app-level.

dependencies {
    implementation "com.google.android.material:$latest_version"
}

And then you can use the snack bar just like toast. For example:

Snackbar.make(view, "Show some message here", Snackbar.LENGTH_SHORT).show()

Step 2: Working with the MainActivity.xml

<?xml version="1.0" encoding="utf-8"?>
<android.support.design.widget.CoordinatorLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/coordinatorLayout"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context="com.example.application.snackbarapp.MainActivity">

    <RelativeLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent">

        <Button
            android:id="@+id/button"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_centerHorizontal="true"
            android:layout_centerVertical="true"
            android:text="show snackbar" />

    </RelativeLayout>

</android.support.design.widget.CoordinatorLayout>

Step 3: Creating a custom layout for a snack bar

Under Layout, the folder creates a layout for the snack bar that must be inflated when creating a snack bar under the mainactivity.java file.

import android.graphics.Color;
import android.support.design.widget.CoordinatorLayout;
import android.support.design.widget.Snackbar;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;

public class MainActivity extends AppCompatActivity {
    private CoordinatorLayout coordinatorLayout;
    private Button button;

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

        coordinatorLayout = findViewById(R.id.coordinatorLayout);
        button = findViewById(R.id.button);

        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                showSnackbar();
            }
        });
    }

    public void showSnackbar() {
        Snackbar snackbar = Snackbar.make(coordinatorLayout, "Marked as Read", Snackbar.LENGTH_INDEFINITE)
                .setAction("UNDO", new View.OnClickListener() {
                    @Override
                    public void onClick(View v) {
                        Snackbar snackbar1 = Snackbar.make(coordinatorLayout, "Undo successful", Snackbar.LENGTH_SHORT);
                        snackbar1.show();
                    }
                })
                .setActionTextColor(Color.RED);

        snackbar.show();
    }
}

Hope you guys are familiar with Spatie Media Library. It's a very useful and time-saving package to manage file uploading.

It's also providing support to convert your images to thumbnails while storing images. you can generate a thumbnail of the image with the size (height, width) you want.

They are calling thumbnails to Conversions. You can generate multiple thumbnails with different sizes as you want.

So let's see some short examples which help us to create thumbnails of an uploaded image.

Implement the HasMediaTrait into your Model

Here we have a User model and we want to generate a thumbnail of the user uploading his profile image. you have to add HasMediaTrait to the User model and need to extend HasMedia.

use IlluminateDatabaseEloquentModel;
use SpatieMediaLibraryModelsMedia;
use SpatieMediaLibraryHasMediaHasMedia;
use SpatieMediaLibraryHasMediaHasMediaTrait;

class User extends Model implements HasMedia
{
    use HasMediaTrait;

    public function registerMediaConversions(Media $media = null)
    {
        $this->addMediaConversion('profile-thumb')
              ->width(150)
              ->height(150);
    }
}

Here we have defined a function registerMediaConversions in which we can manage the size of a thumbnail, which means how much height or width we want for the thumbnail.

So when we upload an image using the media library,

$media = User::first()->addMedia($pathToImage)->toMediaCollection();

it will auto-generate the thumbnails with the given height and width.

How to fetch the generated thumbnail?

$media->getPath();  // the path to the where the original image is stored
$media->getPath('profile-thumb') // the path to the converted image with dimensions 150*150

$media->getUrl();  // the url to the where the original image is stored
$media->getUrl('profile-thumb') // the url to the converted image with dimensions 150*150

How to generate multiple thumbnails for a single image?

..... in User Model .....
use SpatieImageManipulations;

    public function registerMediaConversions(Media $media = null)
    {
        $this->addMediaConversion('profile-thumb')
              ->width(150)
              ->height(150);
    }

        $this->addMediaConversion('old-profile-thumb')
              ->sepia()
              ->border(8, 'black', Manipulations::BORDER_OVERLAY);
    }

so, it will generate 2 thumbnails with different image properties. you can use different image properties directly while generating thumbnails.

That's it, you can read more about the spatie media library conversions (thumbnails) here.

Keep connected to us for more interesting posts about laravel.

While developing apps in Android Studio, developers can create an APK file and share it with other developers or to QA people for testing purposes.

APK can be created with two types:

1. Debug APK
2. Release APK

• Debug APK is very fast in building and Release APK is a little bit slow.

How to create a Release APK File:

• Flowing below all steps
• Open android studio
• Click Build on the toolbar
• Click Generate Signed Bundle/APK.
• Select APK
• Click the Next button
• After clicking the next button, you will see the following dialog.
• Click the "Create new..." button, highlighted in the following image by a red circle if you are creating an APK for the first time. Otherwise, you can choose from existing.
• It will open one another dialog box
• Key store path in select save location .jks file
• Fill in all the information
• Set a valid name for the key alias
• Set 100 as validity years
• Fill Certificate Information
• Click OK
• After you click on it, select "release" from the dialog box
• Select "V1 (Jar Signature)" & "V2 (Full APK Signature)" checkboxes
• Click Finish
• It will start the process of building your APK

How to create a debug .apk file

• Click Build and select Build Bundles(s)/APK(s)
• Select "Build APK(s)" from the dialog box
• It will start the process of building your debug APK file creating

We have recently developed a site into the gatsby. We want to add Google Analytics to the website.

So, this is the way we implemented Google Analytics in the Gatsby site.

Use Gatsby Google GTag Plugin

Gatsby has a plugin gatsby-plugin-google-gtag that be used to easily add Google Global Site Tag to your Gatsby site.

Install the package by running the following command:

npm i gatsby-plugin-google-gtag --save

Configuration

Once the installation is complete, you can now add this plugin to your gatsby-config.js:

Configure trackingIds and other options. Add this into the plugins array. Like,

module.exports = {
  // ...
  plugins: [
    {
      resolve: `gatsby-plugin-google-gtag`,
      options: {
              // You can add multiple tracking ids and a pageview event will be fired for all of them.
              trackingIds: [
                "GA-TRACKING_ID", // Google Analytics / GA
                "AW-CONVERSION_ID", // Google Ads / Adwords / AW
                "DC-FLOODIGHT_ID", // Marketing Platform advertising products (Display & Video 360, Search Ads 360, and Campaign Manager)
              ],
              // This object gets passed directly to the gtag config command
              // This config will be shared across all trackingIds
              gtagConfig: {
                optimize_id: "OPT_CONTAINER_ID",
                anonymize_ip: true,
                cookie_expires: 0,
              },
              // This object is used for configuration specific to this plugin
              pluginConfig: {
                // Puts tracking script in the head instead of the body
                head: false,
                // Setting this parameter is also optional
                respectDNT: true,
                // Avoids sending pageview hits from custom paths
                exclude: ["/preview/**", "/do-not-track/me/too/"],
              },
      },
    },
  ],
}

This plugin automatically sends a “pageview” event to all products given as “trackingIds'' on every Gatsby's route change.

If you want to call a custom event you have access to window.gtag where you can call an event for all products.

Check out this code.

typeof window !== "undefined" && window.gtag("event", "click", { ...data })

NOTE: This plugin only works in production mode! To test your Global Site Tag is installed and

You need to run the following command for firing events correctly.

gatsby build && gatsby serve

If you need to exclude any path from the tracking system, you can add one or more to this optional array.

In the last Blog we have discussed a few tips on recruitment, let's glance at more tips.....

1. Remember only you are not interviewing
2. Look back years of the candidate's career
3. Trust your Gut
4. Don't be boring Interviewer
5. Represent Job Description
6. Think Like a Marketer

1. Remember only you are not interviewing:

Always keep in mind that only you are not hiring for a particular role, we have a competitive job market, most candidates we interview will also be interviewing elsewhere and that's why we need to be active, present a positive company image towards the employee.

2. Look back years of the candidate's career:

If we are hiring for an experienced person we need to ask questions related to his job experience, how he/she was handling difficult situations, and listen closely to the answer. you may learn a lot or what you need. Remember, don't forget to examine body language from it to know about his/her attitude towards the role.

3.Trust your Gut:

don't ignore your gut. If the candidate is found good on paper but still after interviewing something from the inner side tells you it's just not right then don't proceed without more investigation.

4. Don't be boring Interviewer :

Boring questions will bring boring answers. Don't ask such questions. Ask relevant questions about the job. Don't waste your time and candidate time by asking questions that answer doesn't matter to you.

5.Represent Job Description:

While interviewing candidates you need to represent the role and responsibilities for the profile as the candidate becomes more aware of the Job and is able to clear doubts.

6.Think like a Marketer :

Due to competition in the market, Human Resource Recruiters need to be marketer, we have to present our company in a unique way to attract talent from the market.

The process of recruitment is more difficult as all business owners want to hire more talent in the organization. Hence, we need to make proper strategies for hiring as better Recruitment & selection strategies result in the improvement of organizational outcomes. We can say investment in 'Recruitment and Selection process' is money well spent.

Maintaining the integrity of your brand is essential for long-term success. However, Trillion often encounters third-party logo design files that do not appear to have the highest care when created. The logos in question come to us in the form of a sponsor logo, an affiliate logo, and a certificate or award logo.

The following points are often enough that we think it is important to provide guidance so that you can avoid these pitfalls. With the help of a graphic designer, the issues of this logo below can be solved and fixed if you ever consider it in your own logo.

1. Bad lines in the logo

When the characters and design elements in the logo are drawn or modified, great care should be taken by the graphic designer. The lines and dots inside the logo should be smooth and clean. In the logo design example below, you will see how the inside line of the letter does not have a curve towards it. This is one of the most common problems we see in poorly made logos.

Logo files are made up of many dots and lines. When the logo is small, these imperfections may not be significant, but as the logo gets bigger the issue becomes more obvious and problematic. You should have a graphic designer who will fix the curves and lines of the logo. Then use the new files to replace the problem logo.

2. Improper Alignment of Logo Elements

Since graphic designers create logos, they are composing letters and design elements. They have complete control over the sizing and alignment of objects. With all this control, and especially the number of elements or characters is likely to increase that something does not adjust as it should.

As with the "bad lines" example above, a small logo size can hide problems when compared to an extended version. But on the screen or in digital access, cutting your logo the wrong way causes it to look blurry (due to pixel interpolation, solid dark pixels are divided into multiple lighter pixels). Graphic designers can adjust the arrangement of elements using the Snap-to-Grid or Snap-to-Guide feature, functions available in Adobe Creative Cloud software. This process will ensure that items are arranged just like your logo.

3. Missing Font in Logo

A logo design should always be presented as a piece of artwork composed of lines and points or pixels. Unfortunately, this is not always the case. If a graphic designer used a particular font in your logo, you may not have that font on your, or your vendor’s, computer. A missing font often leads to it being substituted by another font available on the computer. It’s a major problem that prevents anyone who doesn’t have the font to see the logo properly. This even holds true for a graphic designer trying to fix the problem.

As a logo is designed, fonts are commonly used either as they are, or as a starting point to be modified for the design. The important step in the logo design process is to “outline” the letters being used in the logo so they become a piece of artwork rather than letters you can edit by typing. Once this process has been done, it is not reversible and the font will no longer be required to view and reproduce the logo. Be aware that fonts can cost between $20 and $150 or more just for one weight, such as Helvetica Neue Bold.

4. The Incorrect Logo File Format

Another one of the most common issues we see with logos that are supplied to us is that they are not in the correct file format. If your graphic designer comes to you and says “it’s not the right format” it can mean a few things. However, if your designer intends on using the logo, it is not going to work.

The most common incorrect file format we receive is a raster logo such as a .jpg rather than a vector logo, such as a .eps. A .jpg logo might be fine if the resolution is high enough and it does not require being produced on a color or transparent background. Vector logos will offer a graphic designer the most options, including saving the artwork to other file formats. A vector logo can be enlarged or reduced infinitely without losing quality.

5. The Incorrect Logo Color Format

A less common but potentially more challenging logo file format issue is the color mode. A logo that is being printed on paper, on a t-shirt, or being included on a website will have different color spectrum requirements. Some can be easily converted from one to another but others cannot. Again, a vector logo will offer a graphic designer the best chance to fix the issue.

Logo Design Done Right

Providing our clients with logo designs and all of the necessary file formats they might need is an important part of our creative process. Once our design has been approved, we create full-color, 1-color, 2-color, black, and white (knockout) versions of the logo for both print and digital usage. We clearly label the files and place them into properly named folders, making it easy to find the right logo.