Tej Pratap Singh

Sometimes when you are running tests in Android Studio or Intellij Idea, you might face a failed case with following error statement:
<blockquote>
test should never throw an exception to this level
</blockquote>
Cause of these errors are usually <code>NullPointer</code> or some other Exception which is not handled properly and statement is not clear where this Exception might be.
Now we can use Debugger to find exact line which is causing this failure.
Here are the steps on how:
<ol>
<li>Press <code>ctrl+shift+F8</code> or search for 'View Breakpoints'</li>
</ol>
You will see a dialog like this:
<img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1668510612650/O34iADbDd.png" alt="image.png">
<ol>
<li>
Check 'Any Exception' checkbox. It will now tell debugger to pause on any line that throws any uncaught exception.
</li>
<li>
Debug you test case and you will get the exact line that is causing this failure.
</li>
</ol>

Android Studio/IntelliJ: How to break on NullPointer or any other Excetion

<code>Mockito.when()</code> allows us to mock behavior of methods in that class. But in order to achieve this we need to mock supplied parameters exactly as our source class expected, If any of our parameter is mismatched, our method will not be mocked and it will return <code>null</code> as a result.
We can avoid this by using ArgumentMatcher and ArgumentCaptor.
Here is a simple example:
<pre><code class="lang-Java">// This is a simple method that has to be mocked
final int addition = calculator.getAddition(2, 3);
</code></pre>
<pre><code class="lang-Java">// For cases, where you do not know exact parameter then you can use Mockito.anyInt()
Mockito.when(mckCalculator.getAddition(Mockito.anyInt(), Mockito.anyInt())).thenReturn(5);
</code></pre>
These <code>any</code> matchers comes too handy when parameters are either computed by program or you simply want to assert if correct parameter are passed to the method.
Similar to <code>any()</code>, we also have type specific matchers, but keep in mind these matcher will not work if your argument is null.
Here is a list of all other matchers available to you:
Mockito.anyInt(), Mockito.anyLong(), Mockito.anyString(), Mockito.anyBoolean(), Mockito.anyByte(), Mockito.anyChar(), Mockito.anyFloat(), Mockito.anyDouble(), Mockito.anyShort(), Mockito.anyList(), Mockito.anySet() and Mockito.anyMap()
Lets see an example:
We have a <code>TaskManager.class</code> which will be mocked eventually.
<pre><code class="lang-Java">public class TaskManager {
 private Map&lt;String, Task&gt; taskMap = new ConcurrentHashMap&lt;&gt;();
 public Task createTask(String name) {
 final task = new Task();
 taskMap.put(name, task);
 return task;
 }

 public void deleteTask(String name) {
 taskMap.remove(name);
 }

 public void executeTask(String name, Runnable runnable) {
 // Some long running task
 runnable.run();
 }
}
</code></pre>
We have another class which uses <code>TaskManager.class</code> internally, lets call it <code>ExampleWorker</code>. We have to write tests for <code>ExampleWorker</code>.
<pre><code class="lang-Java">public class ExampleWorker {
 private final String TASK_NAME = "exampleWorkedTask";

 private final TaskManager mTaskManager;
 private final Task mTask;

 public ExampleTask(TaskManager taskManager) {
 mTaskManager = taskManager;
 mTask = mTaskManager.createTask(TASK_NAME);
 }

 public Task getTask() {
 return mTask;
 }

 public void deleteTask() {
 mTaskManager.deleteTask(TASK_NAME);
 mTask = null;
 }

 public void runTask() {
 mTaskManager.executeTask(TASK_NAME, new Runnable() {
 @Override
 public void run() {
 // Do something here
 }
 });
 }
}
</code></pre>
We can write test for <code>ExampleWorker</code> as below:
<pre><code class="lang-Java">public class ExampleWorkerTest {
 private ExampleWorker classUnderTest;

 private TaskManager mckTaskManager;

 @Before
 public void setUp() throws Exception {
 mckTaskManager = Mockito.mock(TaskManager.class);

 classUnderTest = new ExampleWorker(mckTaskManager);
 }

 @After
 public void tearDown() throws Exception {
 classUnderTest = null;
 }

 @Test
 public void constructor_shouldCreateTask() {
 // Then
 final Task actualResult = classUnderTest.getTask();
 Assert.assertNotNull(actualResult);
 }
}
</code></pre>
Now comes the fun part where we try to test <code>deleteTask()</code> method which will internally call <code>TaskManager</code>'s <code>deleteTask(taskName)</code> method.
We can write simple tests with ArgumentMatcher.
<pre><code class="lang-Java">@Test
public void deleteTask_shouldRemoveTask() {
 // Given
 // There are multiple ways to mock same statement, use eany one of these three based on your requirement
 // You can match exact parameter
 Mockito.doNothing().when(mckTaskManager).deleteTask("exampleWorkedTask");
 // You can match anyString(), but it will not work when string is null
 Mockito.doNothing().when(mckTaskManager).deleteTask(Mockito.anyString());
 // You can match any(), it will work even if parameter String is null
 Mockito.doNothing().when(mckTaskManager).deleteTask(Mockito.any());

 // When
 classUnderTest.deleteTask();

 // Then
 final Task actualResult = classUnderTest.getTask();
 Assert.assertNotNull(actualResult);
}
</code></pre>
But what if we want to assert on the parameters passed while calling <code>deleteTask(taskName)</code> method, we can use ArgumentCaptor
<pre><code class="lang-Java">@Test
public void deleteTask_shouldRemoveTask_assertWithArgumenCaptor() {
 // Given
 final ArgumentCaptor&lt;String&gt; taskNameArgumentMatcher = ArgumentCaptor.forClass(String.class);
 // You can create a captor and validate
 Mockito.doNothing().when(mckTaskManager).deleteTask(taskNameArgumentMatcher.captor());

 // When
 classUnderTest.deleteTask();

 // Then
 // Now we can get the value from taskNameArgumentMatcher and assert it with expectedValue
 final String actualTaskName = taskNameArgumentMatcher.getValue();
 Assert.assertEquals("exampleWorkedTask", actualTaskName);
}
</code></pre>
But guess what, you can also get parameters used with ArgumentMatcher same as ArgumentCaptor. Here is an example:
<pre><code class="lang-Java">@Test
public void deleteTask_shouldRemoveTask_assertWithArgumenMatcher() {
 // Given
 final AtomicReference&lt;String&gt; taskNameReference = new AtomicReference&lt;&gt;();
 Mockito.doAnswer(invocation -&gt; {
 taskNameReference.set(0, invocation.getArgument(0, String.class));
 return null;
 }).when(mckTaskManager).deleteTask(Mockito.anyString());

 // When
 classUnderTest.deleteTask();

 // Then
 // Now we can get the value from taskNameArgumentMatcher and assert it with expectedValue
 final String actualTaskName = taskNameReference.get();
 Assert.assertEquals("exampleWorkedTask", actualTaskName);
}
</code></pre>
P.S. ArgumentMatcher and ArgumentCaptor both work in a similar way difference is just with the syntax. ArgumentCaptor gives clear API to assert the values passed while ArgumentMatcher was general purpose matchers that can do everything.

Mockito: ArgumentMatcher vs ArgumentCaptor

PowerMock is a powerful library that works on byte code level of our program.
This blog will only talk about when and how you need to use <code>@PrepareForTest</code>. If you need to know more about other things PowerMock can do, <a target="_blank" href="https://blog.tejpratapsingh.com/powermock-cheatsheet-tldr-and-tips-cl9cvkr9q000h09l685g2dqhe">read this one first</a>
<h2>PrepareForTest annotation</h2>
PrepareForTest has one job, it will creates a reflection of your class at bytecode level. It allows you to manipulate your source code such that you can change behavior (implementation) of declared methods.
This comes handy when you are working with class or methods that are now allowed to be mocked by Java Reflection.
Here are some f the use cases for PrepareForTest:
<ol>
<li>mock static methods<pre><code class="lang-Java">@RunWith(PowerMockRunner.class)
@PrepareForTest({
 ClassWithStaticMethods.class,
})
public class ClassToTest {
 @Before
 public void setUp() throws Exception {
 PowerMockito.mockStatic(ClassWithStaticMethods.class);
 PowerMockito.when(ClassWithStaticMethods.staticMethod()).thenReturn(someValue);
 }
}
</code></pre>
</li>
<li>
mock final classes/methods:
Mockito cannot mock final methods even if you have created mock of that class. To mock these methods, we need to prepare that class and mock it with <code>PowerMockito.mock()</code>.
<pre><code class="lang-Java">@RunWith(PowerMockRunner.class)
@PrepareForTest({
 FinalClass.class,
 ClassWithFinalMethods.class,
})
public class ClassToTest {
 @Test
 public void testFinalMethods() throws Exception {
 final FinalClass mckFinalClass = PowerMockito.mock(FinalClass.class);
 PowerMockito.when(mckFinalClass.someMethod()).thenReturn(someValue);

 final ClassWithFinalMethods mckClassWithFinalMethods = PowerMockito.mock(ClassWithFinalMethods.class);
 PowerMockito.when(mckClassWithFinalMethods.someFinalMethod()).thenReturn(someValue);
 }
}
</code></pre>
</li>
<li>
Inject with PowerMockito.whenNew()
When you need to inject a mock instead of creating an actual instance of a class, you can use <code>PowerMockito.whenNew()</code>. This will inject your mock whenever new instance is created in your source class.
<pre><code class="lang-Java">// Example Source Class
public class ExampleClass {
 public int getHeight() {
 // Lets say we have a generic method which provides different result base on the provided id
 final CustomClass customClassInstance = new CustomClass();
 return customClass.getHeight();
 }
}
</code></pre>
In this example class, we are creating <code>CustomClass</code> without any injection mechanism, we can inject our mock by adding <code>ExampleClass</code> in <code>PrepareForTest</code> and using <code>PowerMockito.whenNew()</code>:
<pre><code class="lang-Java">@RunWith(PowerMockRunner.class)
@PrepareForTest({
 ExampleClass.class
})
public class ExampleClassTest {

 private ExampleClass classUnderTest;

 @Before
 public void setUp() throws Exception {
 // Create constructor of ExampleClass
 classUnderTest = new ExampleClass();
 }

 @Test
 public void getHeight_shoudReturnHeightOfView() throws NoSuchMethodException {
 final int expectedHeight = 100;
 // Given
 final CustomClass mckCustomClass = Mockito.mock(CustomClass.class);
 Mockito.when(mckCustomClass.getHeight()).theReturn(expectedHeight);
 // Make sure you match exact parameters while mocking (same as we do for Mockito.mock statements).
 // There is also withArguments(first, second, ....)
 // and withAnyArguments() for cases when you don't care for arguments passed.
 PowerMockito.whenNew(CustomClass.class).withNoArguments().thenReturn(mckCustomClass);

 final int actualResult = classUnderTest.getHeight();

 Assert.assertEquals(expectedHeight, actualResult);
 }
}
</code></pre>
</li>
<li>To <code>suppress()</code>, <code>stub()</code> or <code>replace()</code> any method of a Class.
You can modify behavior of methods declared in any class, You can:</li>
<li>
<code>suppress()</code> methods and constructors.<pre><code class="lang-Java">// Suppress Constructor
PowerMockito.suppress(CustomLibClass.class.getConstructors());
// Suppress Method, it will return null if method has a return.
PowerMockito.suppress(CustomLibClass.class.getDeclaredMethod("someMethod"));
</code></pre>
</li>
<li>
<code>stub()</code> methods to return different value.<pre><code class="lang-Java">PowerMockito.stub(CustomLibClass.class.getDeclaredMethod("someMethodThatOnlyWorksOnRumtime")).toReturn(2);
</code></pre>
</li>
<li>
<code>replace()</code> methods to return different value depending on parameter supplied.
<pre><code class="lang-Java">PowerMockito.replace(View.class.getDeclaredMethod("someMethodThatWillReturnDifferentValue", int.class)).with(new InvocationHandler() {
 @Override
 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
 final int viewId = (int) args[0];

 if (viewId == ViewFactory.text_view) {
 // return mock of TextView
 return Mockito.mock(TextView.class);
 } else if (viewId == ViewFactory.image_view) {
 // return mock of ImageView
 return Mockito.mock(ImageView.class);
 }
 // else you can call real method as well
 return method.invoke(proxy, args);
 }
});
</code></pre>
</li>
</ol>

PowerMock: Understanding @PrepareForTest

Powermock CheatSheet: Tldr and Tips

These are some of the useful methods and classes provided by Mockito
<h3>1. Mockito.mock()</h3>
Creates a mock of any class. By default, it will return default value for methods and fields when not mocked.
For Example:
Primitive data types such as <code>byte</code>, <code>short</code>, <code>int</code>, <code>long</code>, <code>float</code>, <code>double</code>, <code>boolean</code> and char will return default value i.e <code>0</code> or <code>false</code>
Non-primitive data types such as <code>String</code>, <code>Arrays</code> and <code>Classes</code> return <code>null</code> when they are not mocked. 
<pre><code class="lang-java">// with annotation
@Mock
private ClassName mock;

// Or with static method
final ClassName mock = Mockito.mock(ClassName.class);

// mock methods that returns something
Mockito.when(mock.sampleMethod()).thenReturn(sampleVal);

// mock method to throw Exception
Mockito.when(mock.sampleMethod()).thenThrow(SampleException.class);

// Mock void methods
Mockito.doNothing().when(mock).method();

// you can get invocation parameters with .thenAnswer()
Mockito.when(mock.sampleMethod(Mockito.any(OtherClass.class))).thenAnswer((Answer&lt;ThirdClass&gt;) invocation -&gt; {
 final OtherClass parameter1 = invocation.getArgument(0);
 return thirdClassObject; 
});

// Verify interactions
Mockito.verify(mock, Mockito.times(1)).sampleMethod();

// Verify, method should not be invoked even once
Mockito.verify(mock, Mockito.never()).sampleMethod2();

// Verify, no methods should be called on given mock
Mockito.verifyNoMoreInteractions(otherMockedClass);
</code></pre>
<h3>2. Mockito.spy()</h3>
It is similar to <code>mock()</code> but instead of return default value it will call the actual implementation when not mocked.
<pre><code class="lang-java">// with annotation
@Spy
private ClassName spy;

// Or with static method
final ClassName spy = Mockito.spy(ClassName.class);

// mock methods that returns something
Mockito.doReturn(value).when(spy).method();

// mock method to throw exception
Mockito.doThrow(new ExceptionClass()).when(spy).metohd();

// mock void methods
Mockito.doNothing().when(spy).method();
</code></pre>
<h3>3. Mockito.mockStatic()</h3>
Now with Mockito 3, you can mock Classes with static methods.
<pre><code class="lang-java">try (MockedStatic&lt;Foo&gt; dummyStatic = Mockito.mockStatic(ClassName.class)) {
 dummyStatic.when(() -&gt; ClassName.method("param1"))
 .thenReturn("someValue");
 // when
 System.out.println(ClassName.method("param1"));
 //then
 dummyStatic.verify(
 () -&gt; ClassName.method("param1"),
 times(1), 
 );
}
</code></pre>
<h3>4. ArgumentMatcher</h3>
Basic Rule to match any statement with Mockito is to correctly match its parameters. If any of the parameter did not match then instruction will not be mocked.
<pre><code class="lang-java">// example statement
final int addition = calculator.getAddition(2, 3);

// you have to match exact parameters, in this case (2,3)
Mockito.when(mckCalculator.getAddition(2, 3)).thenReturn(5);

// If you mock for (3,4), you mocked result will not be returned
Mockito.when(mckCalculator.getAddition(3, 4)).thenReturn(5);

// For cases, where you do not know exact parameter then you can use Mockito.anyInt()
Mockito.when(mckCalculator.getAddition(Mockito.anyInt(), Mockito.anyInt())).thenReturn(5);
</code></pre>
Similarly we have <code>Mockito.any()</code>, <code>Mockito.anyLong()</code>, <code>Mockito.anyString()</code>, <code>Mockito.anyBoolean()</code>, <code>Mockito.anyByte()</code>, <code>Mockito.anyChar()</code>, <code>Mockito.anyFloat()</code>, <code>Mockito.anyDouble()</code>, <code>Mockito.anyShort()</code>, <code>Mockito.anyList()</code>, <code>Mockito.anySet()</code> and <code>Mockito.anyMap()</code>
<h3>5. ArgumentCaptor</h3>
You can also get value of parameters of mocked methods, you can then Assert for their value.
Below is the same example of calculator class.
<pre><code class="lang-java">// example statement
final int addition = calculator.getAddition(2, 3);

// Create captor
ArgumentCaptor&lt;Integer&gt; argumentCaptor = ArgumentCaptor.forClass(Integer.class);

Mockito.when(mckCalculator.getAddition(argumentCaptor.capture(), argumentCaptor.capture())).thenReturn(5);

final int firstNum = argumentCaptor.getValue();
Assert.assertEquals(2, firstNum);

// You can get second num by calling getAllValues()
final int secondNum = argumentCaptor.getAllValues()[1];
Assert.assertEquals(3, secondNum);
</code></pre>

Mockito CheatSheet: Tldr and Tips

In <a target="_blank" rel="noopener noreferrer" href="https://blog.tejpratapsingh.com/android-create-pdf-without-any-library-part-2-ck9eads8g05e3css1bx1mlns2">last part</a> we successfully created a complex Pdf with dynamic data.
After we create a Pdf, we should be able to show contents of Pdf to User, to do that we can use <code>PdfRenderer</code> class and get bitmap of every page inside Pdf.
Here is a simple function you can use to get Pdf pages as Bitmap
<pre><code class="lang-java"> /**
 * Convert PDF to bitmap, only works on devices above LOLLIPOP
 *
 * @param pdfFile pdf file
 * @return list of bitmap of every page
 * @throws Exception
 */
 public static ArrayList&lt;Bitmap&gt; pdfToBitmap(File pdfFile) throws Exception, IllegalStateException {
 if (pdfFile == null || pdfFile.exists() == false) {
 throw new IllegalStateException("");
 }
 if (android.os.Build.VERSION.SDK_INT &lt; android.os.Build.VERSION_CODES.LOLLIPOP) {
 throw new Exception("PDF preview image cannot be generated in this device");
 }
 if (android.os.Build.VERSION.SDK_INT &lt; android.os.Build.VERSION_CODES.LOLLIPOP) {
 return null;
 }

 ArrayList&lt;Bitmap&gt; bitmaps = new ArrayList&lt;&gt;();

 try {
 PdfRenderer renderer = new PdfRenderer(ParcelFileDescriptor.open(pdfFile, ParcelFileDescriptor.MODE_READ_ONLY));

 Bitmap bitmap;
 final int pageCount = renderer.getPageCount();
 for (int i = 0; i &lt; pageCount; i++) {
 PdfRenderer.Page page = renderer.openPage(i);

 int width = page.getWidth();
 int height = page.getHeight();

 /* FOR HIGHER QUALITY IMAGES, USE:
 int width = context.getResources().getDisplayMetrics().densityDpi / 72 * page.getWidth();
 int height = context.getResources().getDisplayMetrics().densityDpi / 72 * page.getHeight();
 */

 bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
 page.render(bitmap, null, null, PdfRenderer.Page.RENDER_MODE_FOR_DISPLAY);

 bitmaps.add(bitmap);

 // close the page
 page.close();
 }
 // close the renderer
 renderer.close();
 } catch (Exception ex) {
 ex.printStackTrace();
 }
 return bitmaps;
 }
</code></pre>
<hr>
To make your work easier i have created a Library to generate dynamic PDF using above methods <a target="_blank" rel="noopener noreferrer" href="https://github.com/tejpratap46/PDFCreatorAndroid">View on Github</a>
 <a target="_blank" rel="noopener noreferrer" href="https://github.com/tejpratap46/PDFCreatorAndroid"><img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1587719632043/mXw6_IETk.png" alt="Simple library to generate and view PDF in Android.png"></a>

Android: Create PDF without any library [Part 3]

In <a target="_blank" rel="noopener noreferrer" href="https://blog.tejpratapsingh.com/android-create-pdf-without-any-library-ck9dz0vdg05agcxs14l1ix0rg">last part</a> we created a static PDF in Android.
But creating PDF from static data has a big disadvantage. You cannot set data at runtime, i.e. you cannot set text from DB or load image from internet.
<h4>Creating PDF: Advanced</h4>
To solve this problem:
<ul>
<li>We will create empty Activity with <code>LinearLayout</code> of size [595xwrap_content], we will get reference of that <code>LinearLayout</code> and Add our Views programmatically.</li>
<li>We only need above LinearLayout so we can calculate height of views we are about to add. As <code>View</code>s 
created programmatically cannot give height they will take after rendering. i.e. rendering of each <code>View</code> is mandatory.</li>
<li>Now we know why we need to first render <code>View</code> to layout, let's proceed:</li>
<li>Let's sat we need to add a <code>TextView</code> to Pdf, we will call it 'textView1'.</li>
<li>'textView1' will be added to 595xwrap_content <code>LinearLayout</code>, So it can render and we take a note of its height.</li>
</ul>
<pre><code class="lang-java">private final Map&lt;String, int&gt; viewToHeightMap = new HashMap&lt;&gt;();

final LinearLayout layout595xwrap_content = findViewById(R.id.layout595xwrap_content);

final TextView textView1 = new TextView(context);
layout595xwrap_content.add(textView1);
textView1.post(new Runnable() {
 void run() {
 layout595xwrap_content.put('textView1', textView1.getHeight())
 }
})
</code></pre>
<ul>
<li>Accordingly add all view to 595xwrap_content <code>LinearLayout</code> one-by-one and take a note of height of each view.</li>
<li>Create <code>LinearLayout</code> of size 595x842px which will be Single Page in Pdf. Add Views one-by-one until height sum reaches 842px.</li>
<li>When 842px height is reached, again create new LinearLayout of size 595x842px which will be Second Page in the Pdf and so on.</li>
<li>After you have create List of <code>LineatLayout</code>s as Pdf Pages, we simply have to <a target="_blank" rel="noopener noreferrer" href="https://blog.tejpratapsingh.com/android-create-pdf-without-any-library-ck9dz0vdg05agcxs14l1ix0rg">use methods</a> in previous part to generate Pdf.</li>
</ul>
In <a target="_blank" rel="noopener noreferrer" href="https://blog.tejpratapsingh.com/android-create-pdf-without-any-library-part-3-ck9eawv4u05edcss1ftdwo5po">Next Part</a> we will generate preview of any Pdf File using <code>PdfRenderer</code>
<hr>
To make your work easier i have created a Library to generate dynamic PDF using above methods <a target="_blank" rel="noopener noreferrer" href="https://github.com/tejpratap46/PDFCreatorAndroid">View on Github</a>
 <a target="_blank" rel="noopener noreferrer" href="https://github.com/tejpratap46/PDFCreatorAndroid"><img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1587719632043/mXw6_IETk.png" alt="Simple library to generate and view PDF in Android.png"></a>

Android: Create PDF without any library [Part 2]

<a target="_blank" rel="noopener noreferrer" href="https://en.wikipedia.org/wiki/PDF">PDF</a> are simple document format with supports text and images. It is simple to share, non editable can be password protected. Great for receipts and invoices.
As i was looking for a library to create PDF natively on Android but couldn't found one that is free to use.
Some time ago, i had a use case where i needed to create PDF on device and unfortunately no free to use library was available at that time which can create PDF's on user's device.
So, i digged into Android's <a target="_blank" rel="noopener noreferrer" href="https://developer.android.com/training/printing/custom-docs.html">Printing custom documents</a> where i came across <a target="_blank" rel="noopener noreferrer" href="https://developer.android.com/reference/android/graphics/pdf/PdfDocument">PdfDocument</a> which can generate PDF from <code>View</code>.
Here is how it is done:
<ol>
<li>
We start by creating a PdfDocument
<pre><code class="lang-java">// Create PDF Document.
PdfDocument pdfDocument = new PdfDocument();
</code></pre>
</li>
<li>
Create a Page in PdfDocument
<pre><code class="lang-java">PdfDocument.PageInfo pageInfo = new PdfDocument.PageInfo.
 Builder((int) PDF_PAGE_WIDTH, (int) PDF_PAGE_HEIGHT, i + 1).create();
</code></pre>
</li>
<li>
Create a view to be printed on PDF
<pre><code class="lang-java">TextView view = new TextView(context);
view.setText("PDF Example");
</code></pre>
</li>
<li>
Draw view on the page
<pre><code class="lang-java">Canvas pageCanvas = page.getCanvas();
pageCanvas.scale(1f, 1f);
int pageWidth = pageCanvas.getWidth();
int pageHeight = pageCanvas.getHeight();
int measureWidth = View.MeasureSpec.makeMeasureSpec(pageWidth, View.MeasureSpec.EXACTLY);
int measuredHeight = View.MeasureSpec.makeMeasureSpec(pageHeight, View.MeasureSpec.EXACTLY);
contentView.measure(measureWidth, measuredHeight);
contentView.layout(0, 0, pageWidth, pageHeight);
contentView.draw(pageCanvas);
</code></pre>
</li>
<li>
Finish the page
<pre><code class="lang-java">pdfDocument.finishPage(page);
</code></pre>
</li>
<li>
Save pdf to file
<pre><code class="lang-java">File pdfFile = new File(mFilePath);
// Write PDFDocument to the file.
FileOutputStream fos = new FileOutputStream(pdfFile);
pdfDocument.writeTo(fos);
// Close output stream
fos.close();
// close the document
pdfDocument.close();
</code></pre>
</li>
</ol>
Above code will create a simple PDF with one page that contains TextView inside it.
<hr>
Now let's start creating an actual PDF...
<h4>Creating PDF: Simple</h4>
PdfDocument API will renders any views to PDF. It is as simple as creating an activity, getting its <code>view</code> and rendering PdfDocument of that view.
<blockquote>
A Simple PDF page is of <code>height="842px"</code> and <code>width="595px"</code>
Note: As dp and sp are device dependent, make sure you create all of your layout in px as it will look same in all devices.
</blockquote>
Steps:
<ol>
<li>Create an <code>Activity</code> which will have a vertical <code>LinearLayout</code> with <code>height="842px"</code> and <code>width="595px"</code>.</li>
<li>Add all views with static data inside it.</li>
<li>Make sure no view exceeds allotted height as it will be trimmed.</li>
<li>If you want to create new page just repeat 1-3.</li>
<li>In your <code>onCreate()</code>, get reference of all <code>LinearLayout</code> and create PDF (using step 4) with each layout as one page.</li>
<li>Done.</li>
</ol>
P.S. in <a target="_blank" rel="noopener noreferrer" href="https://blog.tejpratapsingh.com/android-create-pdf-without-any-library-part-2-ck9eads8g05e3css1bx1mlns2">next chapter</a> we will create more advanced PDF and dynamically insert data and create multi page PDF
<hr>
To make your work easier i have created a Library to generate dynamic PDF using above methods <a target="_blank" rel="noopener noreferrer" href="https://github.com/tejpratap46/PDFCreatorAndroid">View on Github</a>
 <a target="_blank" rel="noopener noreferrer" href="https://github.com/tejpratap46/PDFCreatorAndroid"><img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1587719632043/mXw6_IETk.png" alt="Simple library to generate and view PDF in Android.png"></a>

Android: Create PDF without any library [Part 1]

In my <a target="_blank" rel="noopener noreferrer" href="https://blog.tejpratapsingh.com/rxjs-at-its-basic-ck1mqannv00e68zs1f5qixkzj">previous post</a>, i wrote about how we can design you app using Observer Pattern.
Now we will try something simpler and which works across our application and not bound to a <code>Object</code>.
It has some interesting use cases like listening to Route Change so you can change page header and show logged in user info Or listening an event when next page is loaded.
Event emitter can be achieved with 3 simple steps:
<ol>
<li>Register event</li>
<li>Trigger event</li>
<li>Unregister that event</li>
</ol>
<hr>
So, let's Start:
<h3>Initialisation</h3>
First thing first, we need a global variable to hold all events and their callbacks like this:
<pre><code class="lang-javascript">// events property will hold our events and all the listeners it has.
this.events = {};
</code></pre>
And if you are using ES6 classes, we have to declare this class as singleton, to do that we simply create a global variable and check if variable is initialised or not.
<pre><code class="lang-javascript">let eventManagerInstance = null;
export default class EventManager {
 constructor() {
 if (!eventManagerInstance) {
 console.log("event inttialised");
 eventManagerInstance = this;
 // events hold our events and their callbacks
 this.events = {};
 // eventTypes can be used to keep track of all the events that can be used by this event manager.
 this.eventTypes = {
 ROUTE_CHANGED: "changeRoute",
 SCROLL_DIRECTION_CHANGED: "scrollDirectionChanged",
 SCROLL_LOAD_NEXT_PAGE: "scrollLoadNextPage"
 };
 }
 return eventManagerInstance;
 }
}
</code></pre>
<h3>Register event in Event Manager</h3>
To register a event we need 2 parameters, a unique name for event and a callback function.
<pre><code class="lang-javascript">
/**
 * Register to a event
 *
 * @param {string} eventName Name of event to register for
 * @param {Function} fn callback function
 */
 on(eventName, fn) {
 console.log("event On: " + eventName);
 this.events[eventName] = this.events[eventName] || [];
 this.events[eventName].push(fn);
 }
</code></pre>
<h3>Trigger that event</h3>
After we set up a event listener we can send data via triggers like this,
<pre><code class="lang-javascript">/**
 * Trigger a event with data
 *
 * @param {string} eventName Event to call
 * @param {Object} data optional data to pass
 */
 trigger(eventName, data) {
 console.log("event triggered: " + eventName);
 if (this.events[eventName]) {
 this.events[eventName].forEach(function(fn) {
 fn(data);
 });
 }
 }
</code></pre>
<h3>Unregister that event</h3>
Once we are done listening to a particular event we should be able to unregister.
<pre><code class="lang-javascript"> /**
 * Un-Register from a event
 *
 * @param {string} eventName Name of event to de-register from
 * @param {Function} fn callback function to be removed
 */
 off(eventName, fn) {
 console.log("event Off: " + eventName);
 if (this.events[eventName]) {
 for (var i = 0; i &lt; this.events[eventName].length; i++) {
 if (this.events[eventName][i] === fn) {
 this.events[eventName].splice(i, 1);
 break;
 }
 }
 }
 }
</code></pre>
<hr>
Here is the full implementation of Event Manager class.
<pre><code class="lang-javascript">// This class is implemented as SINGLETON(singleton)
let eventManagerInstance = null;

export default class EventManager {
 constructor() {
 if (!eventManagerInstance) {
 console.log("event inttialised");
 eventManagerInstance = this;
 this.events = {};
 this.eventTypes = {
 ROUTE_CHANGED: "changeRoute",
 SCROLL_DIRECTION_CHANGED: "scrollDirectionChanged",
 SCROLL_LOAD_NEXT_PAGE: "scrollLoadNextPage"
 };
 }
 return eventManagerInstance;
 }

 /**
 * Register to a event
 *
 * @param {string} eventName Name of event to register for
 * @param {Function} fn callback function
 */
 on(eventName, fn) {
 console.log("event On: " + eventName);
 this.events[eventName] = this.events[eventName] || [];
 this.events[eventName].push(fn);
 }

 /**
 * Un-Register from a event
 *
 * @param {string} eventName Name of event to de-register from
 * @param {Function} fn callback function to be removed
 */
 off(eventName, fn) {
 console.log("event Off: " + eventName);
 if (this.events[eventName]) {
 for (var i = 0; i &lt; this.events[eventName].length; i++) {
 if (this.events[eventName][i] === fn) {
 this.events[eventName].splice(i, 1);
 break;
 }
 }
 }
 }

 /**
 * Trigger a event with data
 *
 * @param {string} eventName Event to call
 * @param {Object} data optional data to pass
 */
 trigger(eventName, data) {
 console.log("event triggered: " + eventName);
 if (this.events[eventName]) {
 this.events[eventName].forEach(function(fn) {
 fn(data);
 });
 }
 }
}
</code></pre>
<hr>
<h3>How to use EventManager class</h3>
Using event manager is simple, you just have to subscribe to a event like this:
<pre><code class="lang-javascript">// Get eventManager instance
this.eventManager = new EventManager();

// Declare Event Callback Function, so we can unregister it as sometime.
this.eventCallbackhandler = function(eventData) {
 console.log(eventData);
};

// Subscribe to ROUTE_CHANGED event
this.eventManager.on(
 this.eventManager.eventTypes.ROUTE_CHANGED,
 this.eventCallbackhandler
);
</code></pre>
To Trigger ROUTE_CHANGED from different component, we just have to
<pre><code class="lang-javascript">emitEvent() {
 const eventManager = new EventManager();
 eventManager.trigger(eventManager.eventTypes.ROUTE_CHANGED, {
 eventSource: "EventEmitterComponent"
 });
}
</code></pre>
<hr>
Here is a working sample on <a target="_blank" rel="noopener noreferrer" href="https://codesandbox.io/s/js-event-manager-xnimu">codesandbox.io</a> 
<div class="embed-wrapper">
<div class="embed-loading">
<div class="loadingRow"></div>
<div class="loadingRow"></div>
</div>
<a class="embed-card" data-card-width="600px" data-card-key="2e4d628b39a64b99917c73956a16b477" href="https://codesandbox.io/embed/js-event-manager-xnimu?fontsize=14" data-card-controls="0" data-card-theme="light">https://codesandbox.io/embed/js-event-manager-xnimu?fontsize=14</a>
</div>

Create your own Event Emitter in JS

<h2>ReactiveX or Reactive Extensions</h2>
 <a target="_blank" rel="noopener noreferrer" href="https://github.com/ReactiveX/rxjs">RxJS</a> is javascript implementation of Reactive Extension, it allows you to use <a target="_blank" rel="noopener noreferrer" href="https://en.wikipedia.org/wiki/Observer_pattern">Observer pattern</a> in your web app.
<blockquote>
RxJS is much more than what we are going to learn here, that is why the name (RxJS at its basic)
</blockquote>
At its basic Observer pattern lets you subscribe to changes in subject with the help of events.
First we will focus on <code>Subscribers</code> and <code>Events</code>:
<h3>Subscriber:</h3>
Object has a property named <code>subscribers</code> to manage subscribers who want to listen to changes in our <code>subject</code>.
<pre><code class="lang-javascript">let subscribers= []
</code></pre>
When a subscriber arrives, object adds it to <code>subscribers</code> and when a subscriber wants to unsubscribe, subject should remove subscriber from his <code>subscribers</code>
<h3>Event:</h3>
When data of <code>subject</code> is changed or when <code>subject</code> wants to inform changes to its subscribers it triggers an event. When an event is triggered, it is duty of a subject to inform every subscriber about the event. To do that we just have to iterate over all subscribers and execute their callbacks.
<pre><code class="lang-javascript">this.subscribers.forEach(function(fn) {
 fn(data);
});
</code></pre>
So let's come to the final step of a Observable Pattern and that is <code>Subject</code>
<h3>Subject:</h3>
A subject which just an Object which informs its changes to all of its subscribers.
Here is an example of a general Observable Subject will extend.
<pre><code class="lang-javascript">export default class ObservableSubject {
 constructor() {
 this.subscribers = [];
 }

 getAllSubscribers() {
 return this.subscribers;
 }

 /**
 * Register to a event
 *
 * @param {Function} fn subscriber callback function
 */
 subscribe(fn) {
 this.subscribers.push(fn);
 }

 /**
 * Un-Register from a event
 *
 * @param {Function} fn callback function to be removed
 */
 unsubscribe(eventName, fn) {
 if (this.subscribers) {
 for (var i = 0; i &lt; this.subscribers.length; i++) {
 if (this.subscribers[i] === fn) {
 this.subscribers.splice(i, 1);
 break;
 }
 }
 }
 }

 /**
 * Trigger a event with data
 *
 * @param {Object} data optional data to pass
 */
 trigger(data) {
 if (this.subscribers) {
 this.subscribers.forEach(function(fn) {
 fn(data);
 });
 }
 }
}
</code></pre>
So, let's make a observable User which will extent <code>ObservableSubject</code>
<pre><code class="lang-javascript">import ObservableSubject from "./ObservableSubject";

export default class User extends ObservableSubject {
 setName(name) {
 this.name = name;
 this.trigger({
 user: {
 name: this.name,
 email: this.email
 }
 });
 }

 getName() {
 return this.name;
 }

 setEmail(email) {
 this.email = email;
 this.trigger({
 user: {
 name: this.name,
 email: this.email
 }
 });
 }

 getEmail() {
 return this.email;
 }
}
</code></pre>
And this concludes a basic RxJs implementation.
Complete example is over at <a target="_blank" rel="noopener noreferrer" href="https://codesandbox.io/s/js-event-observer-bvjdd">codesandbox</a> 
<div class="embed-wrapper">
<div class="embed-loading">
<div class="loadingRow"></div>
<div class="loadingRow"></div>
</div>
<a class="embed-card" data-card-width="600px" data-card-key="2e4d628b39a64b99917c73956a16b477" href="https://codesandbox.io/embed/js-event-observer-bvjdd?autoresize=1&amp;expanddevtools=1&amp;fontsize=14&amp;hidenavigation=1&amp;module=%2Fsrc%2FObservableSubject.js" data-card-controls="0" data-card-theme="light">https://codesandbox.io/embed/js-event-observer-bvjdd?autoresize=1&amp;expanddevtools=1&amp;fontsize=14&amp;hidenavigation=1&amp;module=%2Fsrc%2FObservableSubject.js</a>
</div>