Bug #1

If the pattern matches to the end of the string, your function returns false:

String s = "ABC";
String p = "ABC";
System.out.println(isSubString(s, p));

false

Bug #2

Your function isSuffixIsAlsoAPrefix() is off. Given a suffix of "ABCDAC", it returns "A" which is incorrect. This leads to the following failure:

String s = "ABCDACBCDACGX";
String p = "ABCDACG";
System.out.println(isSubString(s, p));

true

Not a true KMP implementation

Even if your code were correct, isSuffixIsAlsoAPrefix() takes \$O(m)\$ time which causes the whole algorithm to take \$O(n*m)\$ time, where \$n\$ is the length of the string and \$m\$ is the length of the pattern. A real KMP implementation would build a partial match table first, so that instead of calling isSuffixIsAlsoAPrefix() on a mismatch, it would instead look up the new value of pIndex from the table. This leads to an overall time of \$O(n+m)\$.

I'm wondering how you came up with your algorithm, because it doesn't resemble any Knuth Morris Pratt implementation that I've ever seen.

First off, I'm unfamiliar with the KMP algorithm, but that may be an advantage :)

Formatting

It's usually a good idea to adhere to the common code formatting standards for Java. This includes having spaces around keywords, brackets and operators and also using bracket blocks even when you only have one statement:

if (pIndex == p.length() - 1) {
  return true;
}

Code cleaup/readablity

The code could do with some minor changes to make it a bit more readable. For example here:

sIndex++;
if(pIndex == p.length()-1)
    return true;
pIndex++;

could actually have the increments together. Either:

if (pIndex == p.length()-1)
    return true;

sIndex++;
pIndex++;

or to avoid the subtraction of 1:

sIndex++;
pIndex++;

if (pIndex == p.length())
    return true;

Another small thing:

matchStarted = (pIndex == 0) ? true : matchStarted;

could be written as:

matchStarted = pIndex == 0 || matchStarted;

Also avoid negations in the conditions of if/else blocks and instead switch the two blocks. For example instead of:

if (!matchStarted) {
  // Do A
} else {
  // Do B
}

do:

if (matchStarted) {
  // Do B
} else {
  // Do A
}

Comments

For me who doesn't know KMP the comments are mostly pointless. Either they just describe what the code is doing anyway:

//Increment both index pointers

Or they don't seem to make sense:

//Are in the middle of matching process and just getting started

How can one be in the middle of the process and just getting started at the same time? Maybe I'm just missing some context. Try having the comments actually describe how the algorithm works.

isSuffixIsAlsoAPrefix

Here the most work could be done. It begins with the name which starts with is... which normally indicates that it returns a boolean, but it doesn't. Also the name doesn't help me understand what it does. Maybe it's again me missing context.

You also should avoid using null when ever you can. In this case you are using null when you could just be using an empty string, because you are only using the length of the result and have a hard coded 0 where you could just use the length of the empty string, which is 0 anyway. It could be:

pIndex  = isSuffixIsAlsoAPrefix(p.substring(0, pIndex)).length();
if (pIndex == 0) {
    matchStarted = false;
}

This leads to the next point: Since you are just using the length of the return value, which you are calculating in the method anyway as matchCharCount, it would make sense to return that instead directly. That way you save the substring operation at the end, which is quite expensive.

Speaking of expensive substring operations: You should also consider not doing the substring when calling isSuffixIsAlsoAPrefix and instead pass the complete string and pIndex as a second parameter, and use the value of pIndex inside the method instead of the string length.

And finally I believe it's not necessary to set matchCharCount to -1 but use 0, which would remove the condition at the end. So at the end the method could look like this:

public static int isSuffixIsAlsoAPrefix(String input, int length) {

    // Changed the check to include 0 length inputs, too.
    // Dropped the null check, because in that case the algorithm 
    // would already have failed much earlier.
    if (length <= 1) {
        return 0;
    }

    int mid = length / 2;
    int left = mid - 1;
    int right = length - 1;
    int matchCharCount = 0;

    while (left >= 0) {
        if (input.charAt(left) == input.charAt(right)) {
            matchCharCount = (matchCharCount == 0) ? left + 1 : matchCharCount;
            right--;
        } else {
            matchCharCount = 0;
        }
        left--;
    }

    return matchCharCount;
}