diff --git a/chartLib/src/main/kotlin/info/appdev/charting/highlight/PieHighlighter.kt b/chartLib/src/main/kotlin/info/appdev/charting/highlight/PieHighlighter.kt
index ea4bdc9df..d846dcf66 100644
--- a/chartLib/src/main/kotlin/info/appdev/charting/highlight/PieHighlighter.kt
+++ b/chartLib/src/main/kotlin/info/appdev/charting/highlight/PieHighlighter.kt
@@ -5,9 +5,9 @@ import info.appdev.charting.data.Entry
 
 open class PieHighlighter(chart: PieChart) : PieRadarHighlighter<PieChart>(chart) {
     override fun getClosestHighlight(index: Int, x: Float, y: Float): Highlight? {
-        val pieDataSet = chartPieRadar.data!!.dataSets[0]
+        val pieDataSet = chartPieRadar.data?.dataSets[0]
 
-        val entry: Entry? = pieDataSet.getEntryForIndex(index)
+        val entry: Entry? = pieDataSet?.getEntryForIndex(index)
 
         entry?.let {
             return Highlight(index.toFloat(), entry.y, x, y, 0, pieDataSet.axisDependency)
diff --git a/chartLib/src/main/kotlin/info/appdev/charting/highlight/RadarHighlighter.kt b/chartLib/src/main/kotlin/info/appdev/charting/highlight/RadarHighlighter.kt
index 12e5c8c2a..23e02577a 100644
--- a/chartLib/src/main/kotlin/info/appdev/charting/highlight/RadarHighlighter.kt
+++ b/chartLib/src/main/kotlin/info/appdev/charting/highlight/RadarHighlighter.kt
@@ -43,21 +43,22 @@ open class RadarHighlighter(chart: RadarChart) : PieRadarHighlighter<RadarChart>
         val factor = chartPieRadar.factor
 
         val pOut = PointF.getInstance(0f, 0f)
-        for (i in 0..<chartPieRadar.data!!.dataSetCount) {
-            val dataSet = chartPieRadar.data!!.getDataSetByIndex(i)
+        chartPieRadar.data?.let { data ->
+            for (i in 0..<data.dataSetCount) {
+                val dataSet = data.getDataSetByIndex(i)
 
-            val entry: Entry? = dataSet?.getEntryForIndex(index)
+                val entry: Entry? = dataSet?.getEntryForIndex(index)
 
-            val y = (entry!!.y - chartPieRadar.yChartMin)
+                val y = (entry!!.y - chartPieRadar.yChartMin)
 
-            chartPieRadar.centerOffsets.changePosition(
-                y * factor * phaseY,
-                sliceAngle * index * phaseX + chartPieRadar.rotationAngle, pOut
-            )
+                chartPieRadar.centerOffsets.changePosition(
+                    y * factor * phaseY,
+                    sliceAngle * index * phaseX + chartPieRadar.rotationAngle, pOut
+                )
 
-            mHighlightBuffer.add(Highlight(index.toFloat(), entry.y, pOut.x, pOut.y, i, dataSet.axisDependency))
+                mHighlightBuffer.add(Highlight(index.toFloat(), entry.y, pOut.x, pOut.y, i, dataSet.axisDependency))
+            }
         }
-
         return mHighlightBuffer
     }
 }
diff --git a/chartLib/src/main/kotlin/info/appdev/charting/listener/BarLineChartTouchListener.kt b/chartLib/src/main/kotlin/info/appdev/charting/listener/BarLineChartTouchListener.kt
index 01b2e0420..8c135f14f 100644
--- a/chartLib/src/main/kotlin/info/appdev/charting/listener/BarLineChartTouchListener.kt
+++ b/chartLib/src/main/kotlin/info/appdev/charting/listener/BarLineChartTouchListener.kt
@@ -494,22 +494,23 @@ class BarLineChartTouchListener(
         onChartGestureListener?.onChartDoubleTapped(e)
 
         // check if double-tap zooming is enabled
-        if (chart.isDoubleTapToZoomEnabled && chart.data!!.entryCount > 0) {
-            val trans = getTrans(e.x, e.y)
+        chart.data?.let { data ->
+            if (chart.isDoubleTapToZoomEnabled && data.entryCount > 0) {
+                val trans = getTrans(e.x, e.y)
 
-            val scaleX = if (chart.isScaleXEnabled) 1.4f else 1f
-            val scaleY = if (chart.isScaleYEnabled) 1.4f else 1f
+                val scaleX = if (chart.isScaleXEnabled) 1.4f else 1f
+                val scaleY = if (chart.isScaleYEnabled) 1.4f else 1f
 
-            chart.zoom(scaleX, scaleY, trans.x, trans.y)
+                chart.zoom(scaleX, scaleY, trans.x, trans.y)
 
-            if (chart.isLogging)
-                Timber.i("Double-Tap, Zooming In, x: ${trans.x} y: ${trans.y}")
+                if (chart.isLogging)
+                    Timber.i("Double-Tap, Zooming In, x: ${trans.x} y: ${trans.y}")
 
-            onChartGestureListener?.onChartScale(e, scaleX, scaleY)
+                onChartGestureListener?.onChartScale(e, scaleX, scaleY)
 
-            PointF.recycleInstance(trans)
+                PointF.recycleInstance(trans)
+            }
         }
-
         return super.onDoubleTap(e)
     }
 
diff --git a/chartLib/src/main/kotlin/info/appdev/charting/renderer/DataRenderer.kt b/chartLib/src/main/kotlin/info/appdev/charting/renderer/DataRenderer.kt
index 080d4344d..09b1c3acd 100644
--- a/chartLib/src/main/kotlin/info/appdev/charting/renderer/DataRenderer.kt
+++ b/chartLib/src/main/kotlin/info/appdev/charting/renderer/DataRenderer.kt
@@ -61,7 +61,9 @@ abstract class DataRenderer(
     }
 
     protected open fun isDrawingValuesAllowed(baseProvider: IBaseProvider<*>): Boolean {
-        return baseProvider.data!!.entryCount < baseProvider.maxVisibleCount * viewPortHandler.scaleX
+        return baseProvider.data?.let { data ->
+            data.entryCount < baseProvider.maxVisibleCount * viewPortHandler.scaleX
+        } ?: run { false }
     }
 
     /**
diff --git a/chartLib/src/main/kotlin/info/appdev/charting/renderer/HorizontalBarChartRenderer.kt b/chartLib/src/main/kotlin/info/appdev/charting/renderer/HorizontalBarChartRenderer.kt
index 4a3a40d37..e5d088650 100644
--- a/chartLib/src/main/kotlin/info/appdev/charting/renderer/HorizontalBarChartRenderer.kt
+++ b/chartLib/src/main/kotlin/info/appdev/charting/renderer/HorizontalBarChartRenderer.kt
@@ -457,6 +457,8 @@ open class HorizontalBarChartRenderer(
     }
 
     override fun isDrawingValuesAllowed(baseProvider: IBaseProvider<*>): Boolean {
-        return baseProvider.data!!.entryCount < baseProvider.maxVisibleCount * viewPortHandler.scaleY
+        return baseProvider.data?.let { data ->
+            data.entryCount < baseProvider.maxVisibleCount * viewPortHandler.scaleY
+        } ?: false
     }
 }
diff --git a/chartLib/src/main/kotlin/info/appdev/charting/renderer/PieChartRenderer.kt b/chartLib/src/main/kotlin/info/appdev/charting/renderer/PieChartRenderer.kt
index 7cc61e8a6..870936b23 100644
--- a/chartLib/src/main/kotlin/info/appdev/charting/renderer/PieChartRenderer.kt
+++ b/chartLib/src/main/kotlin/info/appdev/charting/renderer/PieChartRenderer.kt
@@ -161,12 +161,15 @@ open class PieChartRenderer(
         if (!dataSet.isAutomaticallyDisableSliceSpacingEnabled)
             return dataSet.sliceSpace
 
-        val spaceSizeRatio = dataSet.sliceSpace / viewPortHandler.smallestContentExtension
-        val minValueRatio = dataSet.yMin / chart.data!!.yValueSum * 2
+        chart.data?.let { data ->
+            val spaceSizeRatio = dataSet.sliceSpace / viewPortHandler.smallestContentExtension
+            val minValueRatio = dataSet.yMin / data.yValueSum * 2
 
-        val sliceSpace = if (spaceSizeRatio > minValueRatio) 0f else dataSet.sliceSpace
+            val sliceSpace = if (spaceSizeRatio > minValueRatio) 0f else dataSet.sliceSpace
 
-        return sliceSpace
+            return sliceSpace
+        }
+        return dataSet.sliceSpace
     }
 
     protected fun drawDataSet(dataSet: IPieDataSet) {
@@ -904,46 +907,48 @@ open class PieChartRenderer(
      * This gives all pie-slices a rounded edge.
      */
     protected fun drawRoundedSlices() {
-        if (!chart.isDrawRoundedSlices)
+        if (!chart.isDrawRoundedSlices || chart.data == null)
             return
 
-        val dataSet = chart.data!!.dataSet
+        chart.data?.let { data ->
+            val dataSet = data.dataSet
 
-        if (!dataSet.isVisible)
-            return
+            if (!dataSet.isVisible)
+                return
 
-        val phaseX = animator.phaseX
-        val phaseY = animator.phaseY
+            val phaseX = animator.phaseX
+            val phaseY = animator.phaseY
 
-        val center = chart.centerCircleBox
-        val r = chart.radius
+            val center = chart.centerCircleBox
+            val r = chart.radius
 
-        // calculate the radius of the "slice-circle"
-        val circleRadius = (r - (r * chart.holeRadius / 100f)) / 2f
+            // calculate the radius of the "slice-circle"
+            val circleRadius = (r - (r * chart.holeRadius / 100f)) / 2f
 
-        val drawAngles = chart.drawAngles
-        var angle = chart.rotationAngle
+            val drawAngles = chart.drawAngles
+            var angle = chart.rotationAngle
 
-        for (j in 0..<dataSet.entryCount) {
-            val sliceAngle = drawAngles[j]
+            for (j in 0..<dataSet.entryCount) {
+                val sliceAngle = drawAngles[j]
 
-            dataSet.getEntryForIndex(j)?.let { entry ->
+                dataSet.getEntryForIndex(j)?.let { entry ->
 
-                // draw only if the value is greater than zero
-                if ((abs(entry.y.toDouble()) > Utils.FLOAT_EPSILON)) {
-                    val v = Math.toRadians(
-                        ((angle + sliceAngle) * phaseY).toDouble()
-                    )
-                    val x = ((r - circleRadius) * cos(v) + center.x).toFloat()
-                    val y = ((r - circleRadius) * sin(v) + center.y).toFloat()
+                    // draw only if the value is greater than zero
+                    if ((abs(entry.y.toDouble()) > Utils.FLOAT_EPSILON)) {
+                        val v = Math.toRadians(
+                            ((angle + sliceAngle) * phaseY).toDouble()
+                        )
+                        val x = ((r - circleRadius) * cos(v) + center.x).toFloat()
+                        val y = ((r - circleRadius) * sin(v) + center.y).toFloat()
 
-                    paintRender.color = dataSet.getColorByIndex(j)
-                    bitmapCanvas!!.drawCircle(x, y, circleRadius, paintRender)
+                        paintRender.color = dataSet.getColorByIndex(j)
+                        bitmapCanvas!!.drawCircle(x, y, circleRadius, paintRender)
+                    }
                 }
+                angle += sliceAngle * phaseX
             }
-            angle += sliceAngle * phaseX
+            PointF.recycleInstance(center)
         }
-        PointF.recycleInstance(center)
     }
 
     /**
diff --git a/chartLib/src/main/kotlin/info/appdev/charting/renderer/RadarChartRenderer.kt b/chartLib/src/main/kotlin/info/appdev/charting/renderer/RadarChartRenderer.kt
index bae93e184..dcf35d459 100644
--- a/chartLib/src/main/kotlin/info/appdev/charting/renderer/RadarChartRenderer.kt
+++ b/chartLib/src/main/kotlin/info/appdev/charting/renderer/RadarChartRenderer.kt
@@ -130,67 +130,69 @@ open class RadarChartRenderer(
 
         val yOffset = 5f.convertDpToPixel()
 
-        for (i in 0..<chart.data!!.dataSetCount) {
-            chart.data!!.getDataSetByIndex(i)?.let { dataSet ->
+        chart.data?.let { data ->
+            for (i in 0..<data.dataSetCount) {
+                data.getDataSetByIndex(i)?.let { dataSet ->
 
-                chart.data!!.getDataSetByIndex(i)
-                if (dataSet.entryCount == 0) {
-                    continue
-                }
-                if (!shouldDrawValues(dataSet)) {
-                    continue
-                }
+                    data.getDataSetByIndex(i)
+                    if (dataSet.entryCount == 0) {
+                        continue
+                    }
+                    if (!shouldDrawValues(dataSet)) {
+                        continue
+                    }
 
-                // apply the text-styling defined by the DataSet
-                applyValueTextStyle(dataSet)
-
-                val iconsOffset = PointF.getInstance(dataSet.iconsOffset)
-                iconsOffset.x = iconsOffset.x.convertDpToPixel()
-                iconsOffset.y = iconsOffset.y.convertDpToPixel()
-
-                for (j in 0..<dataSet.entryCount) {
-                    dataSet.getEntryForIndex(j)?.let { entry ->
-
-                        pOut = center.getPosition(
-                            (entry.y - chart.yChartMin) * factor * phaseY,
-                            sliceAngle * j * phaseX + chart.rotationAngle
-                        )
-
-                        if (dataSet.isDrawValues) {
-                            drawValue(
-                                canvas,
-                                dataSet.valueFormatter,
-                                entry.y,
-                                entry,
-                                i,
-                                pOut.x,
-                                pOut.y - yOffset,
-                                dataSet.getValueTextColor(j)
-                            )
-                        }
+                    // apply the text-styling defined by the DataSet
+                    applyValueTextStyle(dataSet)
+
+                    val iconsOffset = PointF.getInstance(dataSet.iconsOffset)
+                    iconsOffset.x = iconsOffset.x.convertDpToPixel()
+                    iconsOffset.y = iconsOffset.y.convertDpToPixel()
 
-                        if (entry.icon != null && dataSet.isDrawIcons) {
-                            val icon = entry.icon
+                    for (j in 0..<dataSet.entryCount) {
+                        dataSet.getEntryForIndex(j)?.let { entry ->
 
-                            pIcon = center.getPosition(
-                                (entry.y) * factor * phaseY + iconsOffset.y,
+                            pOut = center.getPosition(
+                                (entry.y - chart.yChartMin) * factor * phaseY,
                                 sliceAngle * j * phaseX + chart.rotationAngle
                             )
 
-                            pIcon.y += iconsOffset.x
+                            if (dataSet.isDrawValues) {
+                                drawValue(
+                                    canvas,
+                                    dataSet.valueFormatter,
+                                    entry.y,
+                                    entry,
+                                    i,
+                                    pOut.x,
+                                    pOut.y - yOffset,
+                                    dataSet.getValueTextColor(j)
+                                )
+                            }
+
+                            if (entry.icon != null && dataSet.isDrawIcons) {
+                                val icon = entry.icon
 
-                            icon?.let {
-                                canvas.drawImage(
-                                    it,
-                                    pIcon.x.toInt(),
-                                    pIcon.y.toInt()
+                                pIcon = center.getPosition(
+                                    (entry.y) * factor * phaseY + iconsOffset.y,
+                                    sliceAngle * j * phaseX + chart.rotationAngle
                                 )
+
+                                pIcon.y += iconsOffset.x
+
+                                icon?.let {
+                                    canvas.drawImage(
+                                        it,
+                                        pIcon.x.toInt(),
+                                        pIcon.y.toInt()
+                                    )
+                                }
                             }
                         }
                     }
-                }
 
-                PointF.recycleInstance(iconsOffset)
+                    PointF.recycleInstance(iconsOffset)
+                }
             }
         }
 
@@ -218,22 +220,23 @@ open class RadarChartRenderer(
         webPaint.color = chart.webColor
         webPaint.alpha = chart.webAlpha
 
-        val xIncrements = 1 + chart.skipWebLineCount
-        val maxEntryCount = chart.data!!.maxEntryCountSet?.entryCount ?: 0
+        chart.data?.let { data ->
+            val xIncrements = 1 + chart.skipWebLineCount
+            val maxEntryCount = data.maxEntryCountSet?.entryCount ?: 0
 
-        var p = PointF.getInstance(0f, 0f)
-        var i = 0
-        while (i < maxEntryCount) {
-            p = center.getPosition(
-                chart.yRange * factor,
-                sliceAngle * i + rotationAngle
-            )
+            var p = PointF.getInstance(0f, 0f)
+            var i = 0
+            while (i < maxEntryCount) {
+                p = center.getPosition(
+                    chart.yRange * factor,
+                    sliceAngle * i + rotationAngle
+                )
 
-            canvas.drawLine(center.x, center.y, p.x, p.y, webPaint)
-            i += xIncrements
+                canvas.drawLine(center.x, center.y, p.x, p.y, webPaint)
+                i += xIncrements
+            }
+            PointF.recycleInstance(p)
         }
-        PointF.recycleInstance(p)
-
         // draw the inner-web
         webPaint.strokeWidth = chart.webLineWidthInner
         webPaint.color = chart.webColorInner
@@ -248,21 +251,23 @@ open class RadarChartRenderer(
                 innerAreaPath.rewind()
                 paint.color = chart.layerColorList[j]
             }
-            for (i in 0..<chart.data!!.entryCount) {
-                val r = (chart.yAxis.entries[j] - chart.yChartMin) * factor
-
-                p1out = center.getPosition(r, sliceAngle * i + rotationAngle)
-                p2out = center.getPosition(r, sliceAngle * (i + 1) + rotationAngle)
-
-                canvas.drawLine(p1out.x, p1out.y, p2out.x, p2out.y, webPaint)
-                if (chart.isCustomLayerColorEnable) {
-                    if (p1out.x != p2out.x) {
-                        if (i == 0) {
-                            innerAreaPath.moveTo(p1out.x, p1out.y)
-                        } else {
-                            innerAreaPath.lineTo(p1out.x, p1out.y)
+            chart.data?.let { data ->
+                for (i in 0..<data.entryCount) {
+                    val r = (chart.yAxis.entries[j] - chart.yChartMin) * factor
+
+                    p1out = center.getPosition(r, sliceAngle * i + rotationAngle)
+                    p2out = center.getPosition(r, sliceAngle * (i + 1) + rotationAngle)
+
+                    canvas.drawLine(p1out.x, p1out.y, p2out.x, p2out.y, webPaint)
+                    if (chart.isCustomLayerColorEnable) {
+                        if (p1out.x != p2out.x) {
+                            if (i == 0) {
+                                innerAreaPath.moveTo(p1out.x, p1out.y)
+                            } else {
+                                innerAreaPath.lineTo(p1out.x, p1out.y)
+                            }
+                            innerAreaPath.lineTo(p2out.x, p2out.y)
                         }
-                        innerAreaPath.lineTo(p2out.x, p2out.y)
                     }
                 }
             }
diff --git a/chartLib/src/main/kotlin/info/appdev/charting/renderer/XAxisRendererRadarChart.kt b/chartLib/src/main/kotlin/info/appdev/charting/renderer/XAxisRendererRadarChart.kt
index 28063a012..9f0acfc18 100644
--- a/chartLib/src/main/kotlin/info/appdev/charting/renderer/XAxisRendererRadarChart.kt
+++ b/chartLib/src/main/kotlin/info/appdev/charting/renderer/XAxisRendererRadarChart.kt
@@ -31,7 +31,7 @@ class XAxisRendererRadarChart(
 
         val center = chart.centerOffsets
         var pOut = PointF.getInstance(0f, 0f)
-        chart.data!!.maxEntryCountSet?.let { maxEntryCountSet ->
+        chart.data?.maxEntryCountSet?.let { maxEntryCountSet ->
             for (i in 0..<maxEntryCountSet.entryCount) {
                 val label = xAxis.valueFormatter?.getFormattedValue(i.toFloat(), xAxis)
 
diff --git a/chartLib/src/main/kotlin/info/appdev/charting/renderer/YAxisRendererRadarChart.kt b/chartLib/src/main/kotlin/info/appdev/charting/renderer/YAxisRendererRadarChart.kt
index d8a60b210..19be59882 100644
--- a/chartLib/src/main/kotlin/info/appdev/charting/renderer/YAxisRendererRadarChart.kt
+++ b/chartLib/src/main/kotlin/info/appdev/charting/renderer/YAxisRendererRadarChart.kt
@@ -198,7 +198,7 @@ class YAxisRendererRadarChart(
             val limitPath = renderLimitLinesPathBuffer
             limitPath.reset()
 
-            chart.data!!.maxEntryCountSet?.let { maxEntryCountSet ->
+            chart.data?.maxEntryCountSet?.let { maxEntryCountSet ->
                 for (j in 0..<maxEntryCountSet.entryCount) {
                     pOut = center.getPosition(r, sliceAngle * j + chart.rotationAngle)